Untitled-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "parliamentary-contest",
   "metadata": {},
   "source": [
    "# 1. MNIST 데이터셋 가져오기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "persistent-sacrifice",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.keras import datasets, layers, models, losses\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from copy import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "assumed-wedding",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 28, 28)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x_train,y_train),(x_test,y_test) = datasets.mnist.load_data()\n",
    "x_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "resident-aside",
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = x_train.reshape(60000, 28, 28, 1)\n",
    "x_test = x_test.reshape(10000, 28, 28, 1)\n",
    "x_train = np.pad(x_train, ((0,0), (2,2), (2,2), (0,0)), 'constant')\n",
    "x_test = np.pad(x_test, ((0,0), (2,2), (2,2), (0,0)), 'constant')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "loving-visibility",
   "metadata": {},
   "outputs": [],
   "source": [
    "idx = np.argsort(y_test)\n",
    "x_train_sorted = x_test[idx]\n",
    "y_train_sorted = y_test[idx]\n",
    "x_eval_dataset = x_train[48678:]\n",
    "y_eval_dataset = y_train[48678:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "reflected-leave",
   "metadata": {},
   "source": [
    "# 4. 데이터 UE 별로 무작위로 나누기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "civic-battery",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "capital-syntax",
   "metadata": {},
   "source": [
    "##### 1. Balanced Dataset 5개"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "certain-walker",
   "metadata": {},
   "outputs": [],
   "source": [
    "UE = []\n",
    "for _ in range(100):\n",
    "    UE.append({\"x_train\":[], \"y_train\":[]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "quality-terror",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "print(len(random_num_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "transsexual-variation",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "사용한 데이터 수 : 48678\n",
      "[348, 497, 569, 333, 153, 380, 416, 92, 144, 565, 81, 187, 360, 897, 190, 388, 831, 734, 106, 709, 138, 208, 348, 884, 824, 227, 286, 848, 804, 508, 146, 697, 487, 216, 787, 128, 102, 246, 398, 327, 435, 863, 812, 397, 166, 491, 161, 91, 839, 406, 394, 872, 466, 785, 833, 613, 746, 619, 717, 819, 705, 899, 789, 728, 330, 677, 749, 131, 574, 452, 284, 429, 229, 711, 877, 87, 325, 581, 798, 708, 504, 370, 284, 494, 464, 459, 216, 668, 536, 637, 158, 643, 463, 133, 597, 697, 99, 709, 626, 744]\n"
     ]
    }
   ],
   "source": [
    "random.seed(45)\n",
    "\n",
    "total = 0\n",
    "random_num_list = []\n",
    "for _ in range(100):\n",
    "    random_num = random.randrange(70,900)\n",
    "    total += random_num\n",
    "    random_num_list.append(random_num)\n",
    "\n",
    "print('사용한 데이터 수 :',total)\n",
    "print(random_num_list)\n",
    "\n",
    "start = 0\n",
    "for i in range(100):\n",
    "    if i == 0:\n",
    "        UE[i]['x_train'] = x_train[:random_num_list[i]]\n",
    "        UE[i]['y_train'] = y_train[:random_num_list[i]]       \n",
    "    else:\n",
    "        UE[i]['x_train'] = x_train[start:start+random_num_list[i]]\n",
    "        UE[i]['y_train'] = y_train[start:start+random_num_list[i]]\n",
    "    start += random_num_list[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "convinced-talent",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5454\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEgCAYAAABFO1+mAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAY40lEQVR4nO3de7hddZ3f8fdHQBDkOgQGcjGoAQWfok6kWKYOEhWm4mCdakPFiYrlaYuKjhcudWZgpqlUO1Q7o9OHemMUxRSdktIZFFC8VASD4shVIpcQE0hAIRAVSPz2j70im5NzsjbJOXvtcN6v5znPXvu3Lr/vPifZn73Wb621U1VIkrQlT+u6AEnS6DMsJEmtDAtJUivDQpLUyrCQJLUyLCRJrQwLTVtJrkrytg77ryTPbab/R5I/maTtzknycJIdmueT+jqT/EOSRZO1PW0fDAsNXf+bZF/b2Uk+10wfneTXzRte/89Lm/lvSPKdJL9IclUHL2HSVdW/q6q/aFsuyZ1JXtGyrRVV9cyq2ritdfX/Xfq2//tVdcG2blvblx27LkCawKqqmjXBvJ8BHwGeBxwztIq2A0l2rKoNXdehpx73LLTdqaorqmoJsGqQ5ZOckOT6JOuS/CTJceMs85wkX0tyf5L7klyYZK+++acn+WmSh5LcmmRB035EkmXNtu9Nct4W6nhfktVJViV565h5n0nyn5rpfZNcmuSBJD9L8q0kT0vyWWAO8H+aPa33J5nb7KmdnGQF8LW+tv4Pg89Jcm2SB5NckmSfpq+jk6wcU8udSV7R/J7OAv51098Pm/m/OazV1PWBJHclWZPkb5Ps2czbVMeiJCua3+t/HORvptFjWOgpLckRwN8C7wP2Al4G3DneosAHgQOB5wOzgbObbRwCvB14SVXtDhzbt42PAh+tqj2A5wBLJqjjOOC9wCuBecCWDiW9B1gJzAD2p/eGXVX1JmAF8JrmMNOH+tb5vabuYyfY5h8Bb21e3wbgv2+hf+h1eBnwn4EvNv0dPs5ib25+Xg48G3gm8Ndjlvld4BBgAfCnSZ7f1rdGj2GhUXVg88m6/2e3rdjOycCnquryqvp1Vf20qm4Zu1BVLW+WeaSq1gLn0XsDBtgI7AwcmmSnqrqzqn7SzHsMeG6Sfavq4ar67gR1vAH4dFXdUFXraYJoAo8BBwDPqqrHqupb1X4Tt7Oran1V/XKC+Z/t6/tPgDdsGgDfRm8Ezquq26vqYeBMYOGYvZpzquqXVfVD4IfAeKGjEWdYqAsbgZ3GtO1E701yk1VVtdeYn/Vb0dds4CdtCyXZL8lFzaGmdcDngH2hFyTAu+i9wa9pljuwWfVk4GDgliTfS3L8BF0cCNzd9/yuLZTzYWA58NUktyc5o63+Mdtum38Xvd/3vgNst82BPPG13EVvLHT/vrZ7+qZ/QW/vQ9sZw0JdWAHMHdN2EFt+A91ad9M7PNTmg0AB/6Q5pHQSvUNTAFTV56vqd4FnNcv9l6b9tqo6Edivabt4gj2g1fSCa5M5ExVSVQ9V1Xuq6tnAa4A/3jRG0vQ97motr29s348B9wHrgV03zWj2NmY8ie2uovc76d/2BuDelvW0nTEs1IUvAh9IMqsZIH0FvTfFiwdZOckOSXah9wn2aUl2STJ2T2WTTwJvSbKg6WtmkueNs9zuwMPAA0lm0hvj2NTfIUmOSbIz8Cvgl/T2jkhyUpIZVfVr4IFmlfFOWV0CvDnJoUl2Bf5sC6/v+CTPTRJgXbO9Tdu8l97YwJN1Ul/ffw5c3Jxa+2NglySvbn6HH6B3yG2Te4G5SSZ6r/gC8O4kByV5Jo+PcXhG1lOMYaEu/DnwHeDbwM+BDwFvrKob+pY5MJtfZ/GHzbw30XvD/hvgnzfT/3O8jqrqWuAtwH8DHgS+wRM/CW9yDvDiZpn/C3y5b97OwLn0PonfQ28v4qxm3nHAjUkepjfYvbCqfjVOHf9A73Tfr9E7xPS1cX8zPfOAK+iF19XAx6vqqmbeB+kF7QNJ3ruFbYz1WeAzTf27AO9s6noQ+A/AJ4Cf0tvT6D876n81j/cn+f442/1Us+1vAnfQC9N3PIm6tJ2IX34kSWrjnoUkqZVhIUlqZVhIkloZFpKkVoaFJKmVYSFJamVYSJJaGRaSpFZPyS8/2nfffWvu3LldlyFJ25XrrrvuvqqaMd68p2RYzJ07l2XLlnVdhiRtV5JMeDNPD0NJkloZFpKkVoaFJKmVYSFJamVYSJJaGRaSpFaGhSSplWEhSWr1lLwoT9u3Bx98kPXr12/1+rvttht77rnnJFYkqZOwSLIXvS+IfwFQwFuBW4EvAnOBO4E3VNXPm+XPBE4GNgLvrKqvDL1oDcWDDz7InDnPYd26+7d6G3vs8VusWPETA0OaRF3tWXwUuKyq/lWSpwO7AmcBV1bVuUnOAM4ATk9yKLAQOAw4ELgiycFVtbGj2jWF1q9f3wTFdcBvb8UW7mHdut9h/fr1hoU0iYYeFkn2AF4GvBmgqh4FHk1yAnB0s9gFwFXA6cAJwEVV9QhwR5LlwBHA1UMtXEP22/Q+G0jD5WHQ8XWxZ/FsYC3w6SSH0/sIeRqwf1WtBqiq1Un2a5afCXy3b/2VTdsTJDkFOAVgzpw5U1e9pKcsD4NOrIuw2BF4MfCOqromyUfpHXKaSMZpq80aqs4HzgeYP3/+ZvMlqY2HQSfWRVisBFZW1TXN84vphcW9SQ5o9ioOANb0LT+7b/1ZwKqhVStpGvIw6FhDv86iqu4B7k5ySNO0ALgJWAosatoWAZc000uBhUl2TnIQMA+4doglS9K019XZUO8ALmzOhLodeAu94FqS5GRgBfB6gKq6MckSeoGyATjVM6Ekabg6CYuquh6YP86sBRMsvxhYPJU16XGeDSJpLK/g1hN4Noik8RgWegLPBpE0HsNCE/BsEEmP866zkqRWhoUkqZVhIUlqZVhIkloZFpKkVoaFJKmVYSFJamVYSJJaeVGepJHivclGk2Eh6Qm6fLP23mSjy7CQ9Btdv1l7b7LRZVhIY0znwyCj82btvclGjWEh9en6k/Xo8M1aT2RYjKDp/Mm2a6Pwydq/v0aRYTFi/GQ7Krr5ZO3fX6PKsBgxo/DJVt3x769RZViMLI8ZT2/+/TVavIJbktTKsJAktTIsJEmtDAtJUisHuCVphIzqdTadhEWSO4GHgI3Ahqqan2Qf4IvAXOBO4A1V9fNm+TOBk5vl31lVX+mgbEmaUqN8nU2XexYvr6r7+p6fAVxZVecmOaN5fnqSQ4GFwGH0ziW8IsnBVbVx+CVL0tQZ5etsRukw1AnA0c30BcBVwOlN+0VV9QhwR5LlwBHA1R3UKElDMHrX2XQ1wF3AV5Ncl+SUpm3/qloN0Dzu17TPBO7uW3dl0/YESU5JsizJsrVr105h6ZI0/XS1Z3FUVa1Ksh9weZJbtrBsxmmrzRqqzgfOB5g/f/5m8yVJW6+TPYuqWtU8rgH+jt5hpXuTHADQPK5pFl8JzO5bfRawanjVSpKGHhZJdkuy+6Zp4FXADcBSYFGz2CLgkmZ6KbAwyc5JDgLmAdcOt2pJmt66OAy1P/B3STb1//mquizJ94AlSU4GVgCvB6iqG5MsAW4CNgCneiaUJA3X0MOiqm4HDh+n/X5gwQTrLAYWT3FpkqQJeLsPSVIrw0KS1MqwkCS1MiwkSa1G6XYfI2NU7/ooSV0xLMYY5bs+SlJXDIsxRvmuj5LUFcNiQqN310dJ6ooD3JKkVoaFJKmVYSFJamVYSJJaGRaSpFaGhSSplWEhSWplWEiSWhkWkqRWhoUkqZVhIUlqZVhIkloZFpKkVoaFJKmVYSFJamVYSJJatYZFkoMGaZMkPXUNsmfxpXHaLt7WjpPskOQHSS5tnu+T5PIktzWPe/cte2aS5UluTXLstvYtSXpyJvxa1STPAw4D9kzyur5ZewC7TELfpwE3N9sDOAO4sqrOTXJG8/z0JIcCC5taDgSuSHJwVW2chBokSQPY0p7FIcDxwF7Aa/p+Xgz8223pNMks4NXAJ/qaTwAuaKYvAF7b135RVT1SVXcAy4EjtqV/SdKTM+GeRVVdAlyS5KVVdfUk9/sR4P3A7n1t+1fV6qbv1Un2a9pnAt/tW25l0/YESU4BTgGYM2fOJJcrSdPbhGHRZ3mSs4C5/ctX1Vu3psMkxwNrquq6JEcPsso4bbVZQ9X5wPkA8+fP32y+JGnrDRIWlwDfAq4AJmOc4CjgD5L8C3pjH3sk+Rxwb5IDmr2KA4A1zfIrgdl9688CVk1CHZKkAQ0SFrtW1emT1WFVnQmcCdDsWby3qk5K8mFgEXBu83hJs8pS4PNJzqM3wD0PuHay6pEktRvk1NlLm72AqXYu8MoktwGvbJ5TVTcCS4CbgMuAUz0TSpKGa5A9i9OAs5I8AjxGbwyhqmqPLa/WrqquAq5qpu8HFkyw3GJg8bb2J0naOq1hUVW7ty0jSXpqaw2LJC8br72qvjn55UiSRtEgh6He1ze9C70L4q4DjpmSiiRJI2eQw1Cv6X+eZDbwoSmrSJI0crbmFuUrgRdMdiGSpNE1yJjFX/H4FdNPA14I/HAKa5IkjZhBxiyW9U1vAL5QVf9viuqRJI2gQcYsLkjydODgpunWqS1JkjRqBjkMdTS9W4bfSe+CvNlJFnnqrCRNH4MchvpL4FVVdStAkoOBLwC/M5WFSZJGxyBnQ+20KSgAqurHwE5TV5IkadQMNMCd5JPAZ5vnb6R3UZ4kaZoYJCz+PXAq8E56YxbfBD4+lUVJkkbLIGdDPQKc1/xIkqah1jGLJMcn+UGSnyVZl+ShJOuGUZwkaTQMchjqI8DrgB9Vld9tLUnT0CBnQ90N3GBQSNL0NciexfuBv0/yDeCRTY1V5RiGJE0Tg4TFYuBhet9l8fSpLUeSNIoGCYt9qupVU16JJGlkDTJmcUUSw0KSprFBwuJU4LIkv/TUWUmanga5KG/3YRQiSRpdg4xZkGRvYB69QW4AvEW5JE0fg3yfxduA04BZwPXAkcDVwDFTWpkkaWQMMmZxGvAS4K6qejnwImDt1naYZJck1yb5YZIbk5zTtO+T5PIktzWPe/etc2aS5UluTXLs1vYtSdo6g4TFr6rqVwBJdq6qW4BDtqHPR4Bjqupw4IXAcUmOBM4ArqyqecCVzXOSHAosBA4DjgM+nmSHbehfkvQkDRIWK5PsBfxv4PIklwCrtrbD6nm4ebpT81PACfS+vpXm8bXN9AnARVX1SFXdASwHjtja/iVJT94gZ0P9y2by7CRfB/YELtuWTps9g+uA5wIfq6prkuxfVaubPlcn2a9ZfCbw3b7VVzZtY7d5CnAKwJw5c7alPEnSGIPsWfxGVX2jqpZW1aPb0mlVbayqF9IbND8iyQu2sHjG28Q42zy/quZX1fwZM2ZsS3mSpDGeVFhMtqp6ALiK3ljEvUkOAGge1zSLrQRm9602i204DCZJevKGHhZJZjRjICR5BvAK4BZgKbCoWWwRcEkzvRRYmGTnJAfRu97j2qEWLUnT3EAX5U2yA4ALmnGLpwFLqurSJFcDS5KcDKwAXg9QVTcmWQLcBGwATq2qjR3ULUnT1iAX5R0J/BXwfHq3KN8BWF9Ve2xNh1X1j/Su1Rjbfj+wYIJ1FtO7VbokqQODHIb6a+BE4DbgGcDb6IWHJGmaGOgwVFUtT7JDc/jn00m+M8V1SZJGyCBh8YskTweuT/IhYDWw29SWJUkaJYMchnpTs9zbgfX0TmN93VQWJUkaLYOExWur6ldVta6qzqmqPwaOn+rCJEmjY5CwWDRO25snuQ5J0gibcMwiyYnAvwEOSrK0b9buwP1TXZgkaXRsaYD7O/QGs/cF/rKv/SHgH6eyKEnSaJkwLKrqLuAu4KXDK0eSNIpaxyySHJnke0keTvJoko1J1g2jOEnSaPAKbklSK6/gliS18gpuSVKrrb2C+w+nsihJ0mgZ5Du470oyo5k+Z+pLkiSNmgn3LNJzdpL76H2T3Y+TrE3yp8MrT5I0CrZ0GOpdwFHAS6rqt6pqb+CfAkclefcwipMkjYYthcUfASdW1R2bGqrqduCkZp4kaZrYUljsVFX3jW2sqrXATlNXkiRp1GwpLB7dynmSpKeYLZ0NdfgEt/UIsMsU1SNJGkFbupHgDsMsRJI0uga5KE+SNM0ZFpKkVoaFJKnV0MMiyewkX09yc5Ibk5zWtO+T5PIktzWPe/etc2aS5UluTXLssGuWpOmuiz2LDcB7qur5wJHAqUkOBc4ArqyqecCVzXOaeQuBw4DjgI8ncfBdkoZo6GFRVaur6vvN9EPAzcBM4ATggmaxC4DXNtMnABdV1SPN1eTLgSOGWrQkTXOdjlkkmQu8CLgG2L+qVkMvUID9msVmAnf3rbayaRu7rVOSLEuybO3atVNatyRNN52FRZJnAl8C3lVVW/pO74zTVps1VJ1fVfOrav6MGTMmq0xJEh2FRZKd6AXFhVX15ab53iQHNPMPANY07SvpfeHSJrOAVcOqVZLUzdlQAT4J3FxV5/XNWgosaqYXAZf0tS9MsnOSg4B5wLXDqleSNNh3cE+2o+h9VeuPklzftJ0FnAssSXIysAJ4PUBV3ZhkCXATvTOpTq2qjUOvWpKmsaGHRVV9m/HHIQAWTLDOYmDxlBUlSdoir+CWJLUyLCRJrQwLSVIrw0KS1MqwkCS1MiwkSa0MC0lSK8NCktTKsJAktTIsJEmtDAtJUivDQpLUyrCQJLUyLCRJrQwLSVIrw0KS1MqwkCS1MiwkSa0MC0lSK8NCktTKsJAktTIsJEmtDAtJUivDQpLUyrCQJLUaelgk+VSSNUlu6GvbJ8nlSW5rHvfum3dmkuVJbk1y7LDrlSR1s2fxGeC4MW1nAFdW1TzgyuY5SQ4FFgKHNet8PMkOwytVkgQdhEVVfRP42ZjmE4ALmukLgNf2tV9UVY9U1R3AcuCIYdQpSXrcqIxZ7F9VqwGax/2a9pnA3X3LrWzaNpPklCTLkixbu3btlBYrSdPNqITFRDJOW423YFWdX1Xzq2r+jBkzprgsSZpeRiUs7k1yAEDzuKZpXwnM7ltuFrBqyLVJ0rQ3KmGxFFjUTC8CLulrX5hk5yQHAfOAazuoT5KmtR2H3WGSLwBHA/smWQn8GXAusCTJycAK4PUAVXVjkiXATcAG4NSq2jjsmiVpuht6WFTViRPMWjDB8ouBxVNXkSSpzagchpIkjTDDQpLUyrCQJLUyLCRJrQwLSVIrw0KS1MqwkCS1MiwkSa0MC0lSK8NCktTKsJAktTIsJEmtDAtJUivDQpLUyrCQJLUyLCRJrQwLSVIrw0KS1MqwkCS1MiwkSa0MC0lSK8NCktTKsJAktTIsJEmtDAtJUivDQpLUyrCQJLXasesCRtc9Q17P/u3f/u1/VPrfXKpqyjbelSRrgbu2YRP7AvdNUjnbI1+/r9/XPz09q6pmjDfjKRkW2yrJsqqa33UdXfH1+/p9/dP39U/EMQtJUivDQpLUyrAY3/ldF9AxX//05uvXZhyzkCS1cs9CktTKsJAktTIs+iQ5LsmtSZYnOaPreoYpyewkX09yc5Ibk5zWdU1dSLJDkh8kubTrWoYtyV5JLk5yS/Pv4KVd1zRMSd7d/Nu/IckXkuzSdU2jxLBoJNkB+Bjw+8ChwIlJDu22qqHaALynqp4PHAmcOs1e/yanATd3XURHPgpcVlXPAw5nGv0ekswE3gnMr6oXADsAC7utarQYFo87AlheVbdX1aPARcAJHdc0NFW1uqq+30w/RO+NYma3VQ1XklnAq4FPdF3LsCXZA3gZ8EmAqnq0qh7otKjh2xF4RpIdgV2BVR3XM1IMi8fNBO7ue76SafZmuUmSucCLgGs6LmXYPgK8H/h1x3V04dnAWuDTzWG4TyTZreuihqWqfgr8V2AFsBp4sKq+2m1Vo8WweFzGaZt25xUneSbwJeBdVbWu63qGJcnxwJqquq7rWjqyI/Bi4G+q6kXAemDajNsl2ZvekYSDgAOB3ZKc1G1Vo8WweNxKYHbf81lMs93QJDvRC4oLq+rLXdczZEcBf5DkTnqHII9J8rluSxqqlcDKqtq0N3kxvfCYLl4B3FFVa6vqMeDLwD/ruKaRYlg87nvAvCQHJXk6vcGtpR3XNDRJQu949c1VdV7X9QxbVZ1ZVbOqai69v/3XqmrafLKsqnuAu5Mc0jQtAG7qsKRhWwEcmWTX5v/CAqbRAP8g/D6LRlVtSPJ24Cv0zoT4VFXd2HFZw3QU8CbgR0mub9rOqqq/764kDdk7gAubD0u3A2/puJ6hqaprklwMfJ/emYE/wNt+PIG3+5AktfIwlCSplWEhSWplWEiSWhkWkqRWhoUkqZVhIUlqZVhIkloZFpKkVoaFJKmVYSFJamVYSJJaeSNBaYo0XyJ1afM1nZvazgYeBl4A/B7wYDPrF1XlLbE1sgwLqTvvq6qLuy5CGoSHoSRJrQwLqTsfTnJ983Nh18VIW+JhKGnqTPRlMZvaPQyl7YZ7FtLUuR/Ye0zbPsB9HdQibRPDQpoiVfUwsDrJAoAk+wDHAd/utDBpK/i1qtIUSnIo8DEe38P4cFVdmOQzPPHUWYAjqurRIZcoDcSwkCS18jCUJKmVYSFJamVYSJJaGRaSpFaGhSSplWEhSWplWEiSWv1/gY3qAkI6KhQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7843\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8995\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5221\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2341\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5967\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6549\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1353\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2185\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8934\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": [
    "import random\n",
    "from sklearn.model_selection import train_test_split\n",
    "from collections import Counter\n",
    "\n",
    "(x_train, y_train), (x_test, y_test) = datasets.mnist.load_data()\n",
    "\n",
    "x_train = x_train.reshape(60000, 28, 28, 1)\n",
    "x_test = x_test.reshape(10000, 28, 28, 1)\n",
    "x_train = np.pad(x_train, ((0, 0), (2, 2), (2, 2), (0, 0)), 'constant')\n",
    "x_test = np.pad(x_test, ((0, 0), (2, 2), (2, 2), (0, 0)), 'constant')\n",
    "idx = np.argsort(y_test)\n",
    "x_train_sorted = x_test[idx]\n",
    "y_train_sorted = y_test[idx]\n",
    "\n",
    "UE_NUM = 10\n",
    "\n",
    "UE = []\n",
    "for _ in range(UE_NUM):\n",
    "    UE.append({\"x_train\": [], \"y_train\": []})\n",
    "\n",
    "random.seed(45)\n",
    "\n",
    "total = 0\n",
    "random_num_list = []\n",
    "for _ in range(UE_NUM):\n",
    "    random_num = random.randrange(1000, 12000)\n",
    "    total += random_num\n",
    "    random_num_list.append(random_num)\n",
    "\n",
    "x_eval_dataset = x_train[total:]\n",
    "y_eval_dataset = y_train[total:]\n",
    "\n",
    "start = 0\n",
    "for i in range(UE_NUM):\n",
    "    if i == 0:\n",
    "        UE[i]['x_train'] = x_train[:random_num_list[i]]\n",
    "        UE[i]['y_train'] = y_train[:random_num_list[i]]\n",
    "    else:\n",
    "        UE[i]['x_train'] = x_train[start:start+random_num_list[i]]\n",
    "        UE[i]['y_train'] = y_train[start:start+random_num_list[i]]\n",
    "    start += random_num_list[i]\n",
    "\n",
    "x_train, x_test, y_train, y_test = [], [], [], []\n",
    "for i in range(UE_NUM):\n",
    "    x_train_temp, x_test_temp, y_train_temp, y_test_temp = train_test_split(\n",
    "        UE[i]['x_train'], UE[i]['y_train'], test_size=0.2, random_state=45)\n",
    "    x_train.append(x_train_temp)\n",
    "    x_test.append(x_test_temp)\n",
    "    y_train.append(y_train_temp)\n",
    "    y_test.append(y_test_temp)\n",
    "    \n",
    "for x in range(10):\n",
    "    print(len(UE[x]['y_train']))\n",
    "    \n",
    "    temp = []\n",
    "\n",
    "    for a in Counter(UE[x]['y_train']).values():\n",
    "        temp.append(a)\n",
    "\n",
    "    bar_chart = plt.bar(np.arange(10), temp, width=0.5, bottom=2, align='edge', label='A', \n",
    "                        color='b', edgecolor='black', linewidth=1.2)\n",
    "\n",
    "    plt.title(f'UE{x+1} class distribution', pad=10)\n",
    "    plt.xlabel('UE', labelpad=10)\n",
    "    plt.ylabel('Data amount', labelpad=10)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "sustained-alloy",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "finnish-jason",
   "metadata": {},
   "source": [
    "# 5. 연합학습"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "delayed-commercial",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "occupational-beauty",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "3/3 [==============================] - 0s 69ms/step - loss: 2.3347 - accuracy: 0.0683 - val_loss: 2.2435 - val_accuracy: 0.1286\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "4/4 [==============================] - 0s 40ms/step - loss: 2.3270 - accuracy: 0.0705 - val_loss: 2.2734 - val_accuracy: 0.0800\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "5/5 [==============================] - 0s 38ms/step - loss: 2.3344 - accuracy: 0.0923 - val_loss: 2.2204 - val_accuracy: 0.1754\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "3/3 [==============================] - 0s 62ms/step - loss: 2.4041 - accuracy: 0.1053 - val_loss: 2.3436 - val_accuracy: 0.1642\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "2/2 [==============================] - ETA: 0s - loss: 2.4440 - accuracy: 0.0410WARNING:tensorflow:5 out of the last 6 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174A92300D0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2/2 [==============================] - 0s 91ms/step - loss: 2.4440 - accuracy: 0.0410 - val_loss: 2.2740 - val_accuracy: 0.0968\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "4/4 [==============================] - ETA: 0s - loss: 2.2565 - accuracy: 0.1941WARNING:tensorflow:6 out of the last 7 calls to <function Model.make_test_function.<locals>.test_function at 0x00000173626F2310> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - 0s 46ms/step - loss: 2.2565 - accuracy: 0.1941 - val_loss: 2.2501 - val_accuracy: 0.2632\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "WARNING:tensorflow:5 out of the last 15 calls to <function Model.make_train_function.<locals>.train_function at 0x00000174C416C550> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - ETA: 0s - loss: 2.3213 - accuracy: 0.1145WARNING:tensorflow:7 out of the last 8 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174C4C365E0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - 0s 46ms/step - loss: 2.3213 - accuracy: 0.1145 - val_loss: 2.2782 - val_accuracy: 0.1310\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/1 [==============================] - ETA: 0s - loss: 2.3274 - accuracy: 0.0822WARNING:tensorflow:8 out of the last 9 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017495125CA0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/1 [==============================] - 0s 127ms/step - loss: 2.3274 - accuracy: 0.0822 - val_loss: 2.3415 - val_accuracy: 0.0000e+00\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:5 out of the last 12 calls to <function Model.make_train_function.<locals>.train_function at 0x00000174CDB24670> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - ETA: 0s - loss: 2.4623 - accuracy: 0.0957WARNING:tensorflow:9 out of the last 10 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174D0C30040> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - 0s 92ms/step - loss: 2.4623 - accuracy: 0.0957 - val_loss: 2.2456 - val_accuracy: 0.2069\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "WARNING:tensorflow:5 out of the last 12 calls to <function Model.make_train_function.<locals>.train_function at 0x00000174D83F30D0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "5/5 [==============================] - ETA: 0s - loss: 2.3569 - accuracy: 0.0973WARNING:tensorflow:10 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174D8684160> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "5/5 [==============================] - 0s 38ms/step - loss: 2.3569 - accuracy: 0.0973 - val_loss: 2.3273 - val_accuracy: 0.1504\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "WARNING:tensorflow:5 out of the last 13 calls to <function Model.make_train_function.<locals>.train_function at 0x00000174D87BC160> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/1 [==============================] - ETA: 0s - loss: 2.4253 - accuracy: 0.0312WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174DE9E23A0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/1 [==============================] - 0s 130ms/step - loss: 2.4253 - accuracy: 0.0312 - val_loss: 2.3374 - val_accuracy: 0.1176\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:6 out of the last 14 calls to <function Model.make_train_function.<locals>.train_function at 0x00000174DEAEA5E0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - ETA: 0s - loss: 2.5027 - accuracy: 0.0805WARNING:tensorflow:10 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174DECAA670> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - 0s 163ms/step - loss: 2.5027 - accuracy: 0.0805 - val_loss: 2.4282 - val_accuracy: 0.1053\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "WARNING:tensorflow:5 out of the last 11 calls to <function Model.make_train_function.<locals>.train_function at 0x00000174D853C280> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "3/3 [==============================] - ETA: 0s - loss: 2.2638 - accuracy: 0.2257WARNING:tensorflow:10 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174DECAAA60> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "3/3 [==============================] - 0s 62ms/step - loss: 2.2638 - accuracy: 0.2257 - val_loss: 2.2710 - val_accuracy: 0.1389\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "WARNING:tensorflow:5 out of the last 12 calls to <function Model.make_train_function.<locals>.train_function at 0x00000174DEE11AF0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/8 [==>...........................] - ETA: 0s - loss: 2.6062 - accuracy: 0.0800WARNING:tensorflow:10 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174EA2D8820> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "8/8 [==============================] - 0s 22ms/step - loss: 2.4359 - accuracy: 0.0683 - val_loss: 2.2973 - val_accuracy: 0.1278\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/2 [==============>...............] - ETA: 0s - loss: 2.4384 - accuracy: 0.1200WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174EB687A60> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - 0s 55ms/step - loss: 2.4144 - accuracy: 0.1118 - val_loss: 2.4812 - val_accuracy: 0.0789\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "4/4 [==============================] - ETA: 0s - loss: 2.3866 - accuracy: 0.1129WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174EBA69CA0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - 0s 41ms/step - loss: 2.3866 - accuracy: 0.1129 - val_loss: 2.3313 - val_accuracy: 0.1667\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/7 [===>..........................] - ETA: 0s - loss: 2.3791 - accuracy: 0.1200WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174ECF5B0D0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "7/7 [==============================] - 0s 17ms/step - loss: 2.2924 - accuracy: 0.1401 - val_loss: 2.1441 - val_accuracy: 0.2695\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "6/6 [==============================] - ETA: 0s - loss: 2.3437 - accuracy: 0.1261WARNING:tensorflow:9 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174EE3101F0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 0s 62ms/step - loss: 2.3437 - accuracy: 0.1261 - val_loss: 2.2786 - val_accuracy: 0.1701\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - ETA: 0s - loss: 2.4634 - accuracy: 0.1429WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174D0C30AF0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/1 [==============================] - 0s 106ms/step - loss: 2.4634 - accuracy: 0.1429 - val_loss: 2.2357 - val_accuracy: 0.2273\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/6 [====>.........................] - ETA: 0s - loss: 2.4069 - accuracy: 0.1300WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174EE8444C0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 0s 28ms/step - loss: 2.3865 - accuracy: 0.1182 - val_loss: 2.2615 - val_accuracy: 0.1620\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/2 [==============>...............] - ETA: 0s - loss: 2.2703 - accuracy: 0.1200WARNING:tensorflow:8 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174EFBDD0D0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - 0s 65ms/step - loss: 2.2437 - accuracy: 0.1273 - val_loss: 2.2616 - val_accuracy: 0.1429\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "WARNING:tensorflow:5 out of the last 16 calls to <function Model.make_train_function.<locals>.train_function at 0x00000174EFD141F0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/2 [==============>...............] - ETA: 0s - loss: 2.2701 - accuracy: 0.2000WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174EFF9A1F0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2/2 [==============================] - 0s 55ms/step - loss: 2.2666 - accuracy: 0.1988 - val_loss: 2.2414 - val_accuracy: 0.0952\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/3 [=========>....................] - ETA: 0s - loss: 2.3769 - accuracy: 0.0500WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174F133D430> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "3/3 [==============================] - 0s 36ms/step - loss: 2.3891 - accuracy: 0.0791 - val_loss: 2.2735 - val_accuracy: 0.0857\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "WARNING:tensorflow:5 out of the last 14 calls to <function Model.make_train_function.<locals>.train_function at 0x00000174F14785E0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "8/8 [==============================] - ETA: 0s - loss: 2.3184 - accuracy: 0.0990WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174F1635670> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "8/8 [==============================] - 0s 25ms/step - loss: 2.3184 - accuracy: 0.0990 - val_loss: 2.1685 - val_accuracy: 0.2599\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "7/7 [==============================] - ETA: 0s - loss: 2.2402 - accuracy: 0.1851WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174F29CE8B0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "7/7 [==============================] - 0s 27ms/step - loss: 2.2402 - accuracy: 0.1851 - val_loss: 2.1200 - val_accuracy: 0.2667\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2/2 [==============================] - ETA: 0s - loss: 2.2901 - accuracy: 0.1602WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174EFBDDDC0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - 0s 91ms/step - loss: 2.2901 - accuracy: 0.1602 - val_loss: 2.2173 - val_accuracy: 0.1739\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/3 [=========>....................] - ETA: 0s - loss: 2.3844 - accuracy: 0.1100WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174F29CE9D0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "3/3 [==============================] - 0s 53ms/step - loss: 2.3653 - accuracy: 0.1096 - val_loss: 2.2804 - val_accuracy: 0.0690\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/7 [===>..........................] - ETA: 0s - loss: 2.3227 - accuracy: 0.1800WARNING:tensorflow:9 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174F40538B0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "7/7 [==============================] - 0s 17ms/step - loss: 2.2742 - accuracy: 0.1799 - val_loss: 2.1825 - val_accuracy: 0.3000\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "7/7 [==============================] - ETA: 0s - loss: 2.3583 - accuracy: 0.0980WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174F442EAF0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "7/7 [==============================] - 0s 28ms/step - loss: 2.3583 - accuracy: 0.0980 - val_loss: 2.2976 - val_accuracy: 0.1429\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5/5 [==============================] - ETA: 0s - loss: 2.3351 - accuracy: 0.1108WARNING:tensorflow:7 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174F57DDD30> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "5/5 [==============================] - 0s 37ms/step - loss: 2.3351 - accuracy: 0.1108 - val_loss: 2.2468 - val_accuracy: 0.1863\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "2/2 [==============================] - ETA: 0s - loss: 2.4108 - accuracy: 0.1293WARNING:tensorflow:7 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174F6CD00D0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - 0s 92ms/step - loss: 2.4108 - accuracy: 0.1293 - val_loss: 2.1849 - val_accuracy: 0.2667\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "6/6 [==============================] - ETA: 0s - loss: 2.3899 - accuracy: 0.1113WARNING:tensorflow:8 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174F70B41F0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 0s 32ms/step - loss: 2.3899 - accuracy: 0.1113 - val_loss: 2.2755 - val_accuracy: 0.2214\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "4/4 [==============================] - ETA: 0s - loss: 2.3292 - accuracy: 0.1183WARNING:tensorflow:7 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174F7462430> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - 0s 47ms/step - loss: 2.3292 - accuracy: 0.1183 - val_loss: 2.2614 - val_accuracy: 0.1633\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/2 [==============>...............] - ETA: 0s - loss: 2.3420 - accuracy: 0.0900WARNING:tensorflow:7 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174F71CD280> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - 0s 81ms/step - loss: 2.3103 - accuracy: 0.0988 - val_loss: 2.3132 - val_accuracy: 0.1364\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/7 [===>..........................] - ETA: 0s - loss: 2.4896 - accuracy: 0.0100WARNING:tensorflow:8 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174F4053670> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "7/7 [==============================] - 0s 21ms/step - loss: 2.3255 - accuracy: 0.0715 - val_loss: 2.2645 - val_accuracy: 0.1456\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/2 [==============>...............] - ETA: 0s - loss: 2.3599 - accuracy: 0.1600WARNING:tensorflow:8 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174F8A25B80> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - 0s 80ms/step - loss: 2.3608 - accuracy: 0.1569 - val_loss: 2.5589 - val_accuracy: 0.0769\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/1 [==============================] - ETA: 0s - loss: 2.4419 - accuracy: 0.0988WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174F9DD5E50> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/1 [==============================] - 0s 127ms/step - loss: 2.4419 - accuracy: 0.0988 - val_loss: 2.4358 - val_accuracy: 0.0476\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2/2 [==============================] - ETA: 0s - loss: 2.3895 - accuracy: 0.0714WARNING:tensorflow:9 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174FB2C90D0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - 0s 92ms/step - loss: 2.3895 - accuracy: 0.0714 - val_loss: 2.3154 - val_accuracy: 0.1400\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "WARNING:tensorflow:5 out of the last 13 calls to <function Model.make_train_function.<locals>.train_function at 0x00000174FB2C9160> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - ETA: 0s - loss: 2.3416 - accuracy: 0.1038WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174FB520B80> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - 0s 41ms/step - loss: 2.3416 - accuracy: 0.1038 - val_loss: 2.2730 - val_accuracy: 0.1375\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "WARNING:tensorflow:6 out of the last 17 calls to <function Model.make_train_function.<locals>.train_function at 0x00000174FB67E310> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/3 [=========>....................] - ETA: 0s - loss: 2.3860 - accuracy: 0.0800WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174FB901DC0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "3/3 [==============================] - 0s 46ms/step - loss: 2.3430 - accuracy: 0.0920 - val_loss: 2.2613 - val_accuracy: 0.2121\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:5 out of the last 11 calls to <function Model.make_train_function.<locals>.train_function at 0x00000174FB520DC0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - ETA: 0s - loss: 2.4133 - accuracy: 0.0805WARNING:tensorflow:10 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174FCF02160> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - 0s 42ms/step - loss: 2.4133 - accuracy: 0.0805 - val_loss: 2.3658 - val_accuracy: 0.1149\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "7/7 [==============================] - ETA: 0s - loss: 2.3237 - accuracy: 0.1507WARNING:tensorflow:10 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174FE29A280> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "7/7 [==============================] - 0s 24ms/step - loss: 2.3237 - accuracy: 0.1507 - val_loss: 2.2270 - val_accuracy: 0.2659\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/7 [===>..........................] - ETA: 0s - loss: 2.3463 - accuracy: 0.1500WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174FE57E5E0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "7/7 [==============================] - 0s 20ms/step - loss: 2.3444 - accuracy: 0.1217 - val_loss: 2.2399 - val_accuracy: 0.1166\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/4 [======>.......................] - ETA: 0s - loss: 2.4229 - accuracy: 0.1100WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174FE946820> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4/4 [==============================] - 0s 28ms/step - loss: 2.4438 - accuracy: 0.1009 - val_loss: 2.4158 - val_accuracy: 0.0750\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/2 [==============>...............] - ETA: 0s - loss: 2.3956 - accuracy: 0.0200WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174FCA2BF70> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - 0s 65ms/step - loss: 2.3772 - accuracy: 0.0455 - val_loss: 2.3739 - val_accuracy: 0.0294\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "4/4 [==============================] - ETA: 0s - loss: 2.3973 - accuracy: 0.1097WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174F9B51A60> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - 0s 47ms/step - loss: 2.3973 - accuracy: 0.1097 - val_loss: 2.2878 - val_accuracy: 0.1414\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/2 [==============>...............] - ETA: 0s - loss: 2.3845 - accuracy: 0.1100WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174FFDECB80> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - 0s 65ms/step - loss: 2.3665 - accuracy: 0.1250 - val_loss: 2.2544 - val_accuracy: 0.1818\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:5 out of the last 13 calls to <function Model.make_train_function.<locals>.train_function at 0x00000174FFF45D30> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/1 [==============================] - ETA: 0s - loss: 2.3792 - accuracy: 0.1111WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017321194DC0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/1 [==============================] - 0s 106ms/step - loss: 2.3792 - accuracy: 0.1111 - val_loss: 2.3783 - val_accuracy: 0.1053\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "WARNING:tensorflow:6 out of the last 14 calls to <function Model.make_train_function.<locals>.train_function at 0x0000017321194F70> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "7/7 [==============================] - ETA: 0s - loss: 2.3427 - accuracy: 0.2042WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017501278040> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "7/7 [==============================] - 0s 28ms/step - loss: 2.3427 - accuracy: 0.2042 - val_loss: 2.2268 - val_accuracy: 0.2500\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "4/4 [==============================] - ETA: 0s - loss: 2.3143 - accuracy: 0.1451WARNING:tensorflow:9 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017501658280> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - 0s 46ms/step - loss: 2.3143 - accuracy: 0.1451 - val_loss: 2.2199 - val_accuracy: 0.1707\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/4 [======>.......................] - ETA: 0s - loss: 2.4497 - accuracy: 0.1000WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000175029EB4C0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - 0s 34ms/step - loss: 2.3958 - accuracy: 0.1238 - val_loss: 2.3491 - val_accuracy: 0.1392\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/7 [===>..........................] - ETA: 0s - loss: 2.4979 - accuracy: 0.0600WARNING:tensorflow:10 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017502CCF700> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "7/7 [==============================] - 0s 20ms/step - loss: 2.4212 - accuracy: 0.0933 - val_loss: 2.3065 - val_accuracy: 0.1657\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/4 [======>.......................] - ETA: 0s - loss: 2.3445 - accuracy: 0.0900WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x000001750309A940> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - 0s 34ms/step - loss: 2.3200 - accuracy: 0.1156 - val_loss: 2.2538 - val_accuracy: 0.0957\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/7 [===>..........................] - ETA: 0s - loss: 2.5229 - accuracy: 0.0700WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017504449C10> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "7/7 [==============================] - 0s 18ms/step - loss: 2.3880 - accuracy: 0.0669 - val_loss: 2.2811 - val_accuracy: 0.1401\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/7 [===>..........................] - ETA: 0s - loss: 2.2668 - accuracy: 0.1100WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017504829E50> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "7/7 [==============================] - 0s 17ms/step - loss: 2.2094 - accuracy: 0.1471 - val_loss: 2.0521 - val_accuracy: 0.2754\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/5 [=====>........................] - ETA: 0s - loss: 2.4701 - accuracy: 0.0700WARNING:tensorflow:8 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017505D1C040> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "5/5 [==============================] - 0s 28ms/step - loss: 2.3927 - accuracy: 0.1082 - val_loss: 2.2893 - val_accuracy: 0.1463\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/6 [====>.........................] - ETA: 0s - loss: 2.3875 - accuracy: 0.0800WARNING:tensorflow:7 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017506F48AF0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 1s 86ms/step - loss: 2.3184 - accuracy: 0.1326 - val_loss: 2.2182 - val_accuracy: 0.1800\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "5/5 [==============================] - ETA: 0s - loss: 2.3289 - accuracy: 0.0889WARNING:tensorflow:7 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x00000175018E7F70> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "WARNING:tensorflow:Callbacks method `on_test_batch_end` is slow compared to the batch time (batch time: 0.0000s vs `on_test_batch_end` time: 0.0010s). Check your callbacks.\n",
      "5/5 [==============================] - 0s 34ms/step - loss: 2.3289 - accuracy: 0.0889 - val_loss: 2.2616 - val_accuracy: 0.1452\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/6 [====>.........................] - ETA: 0s - loss: 2.3395 - accuracy: 0.0700WARNING:tensorflow:6 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000174FFDEC790> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 0s 19ms/step - loss: 2.2740 - accuracy: 0.1414 - val_loss: 2.2152 - val_accuracy: 0.1944\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/7 [===>..........................] - ETA: 0s - loss: 2.3471 - accuracy: 0.0700WARNING:tensorflow:6 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017508525040> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "7/7 [==============================] - 0s 17ms/step - loss: 2.2747 - accuracy: 0.1160 - val_loss: 2.1935 - val_accuracy: 0.1890\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/6 [====>.........................] - ETA: 0s - loss: 2.4485 - accuracy: 0.0600WARNING:tensorflow:6 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017508901160> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 0s 23ms/step - loss: 2.3309 - accuracy: 0.1330 - val_loss: 2.2349 - val_accuracy: 0.2128\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/8 [==>...........................] - ETA: 0s - loss: 2.4082 - accuracy: 0.0500WARNING:tensorflow:6 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017509C953A0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "8/8 [==============================] - 0s 19ms/step - loss: 2.3039 - accuracy: 0.0834 - val_loss: 2.1881 - val_accuracy: 0.1667\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/7 [===>..........................] - ETA: 0s - loss: 2.4431 - accuracy: 0.0400WARNING:tensorflow:6 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017509F775E0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "7/7 [==============================] - 0s 21ms/step - loss: 2.3685 - accuracy: 0.0777 - val_loss: 2.2454 - val_accuracy: 0.1772\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/6 [====>.........................] - ETA: 0s - loss: 2.3105 - accuracy: 0.1600WARNING:tensorflow:6 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x000001750B3FD0D0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 0s 25ms/step - loss: 2.2880 - accuracy: 0.1701 - val_loss: 2.2162 - val_accuracy: 0.1781\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/3 [=========>....................] - ETA: 0s - loss: 2.4299 - accuracy: 0.1600WARNING:tensorflow:6 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x000001750B7BE310> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "3/3 [==============================] - 0s 36ms/step - loss: 2.4408 - accuracy: 0.1364 - val_loss: 2.3722 - val_accuracy: 0.1212\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/6 [====>.........................] - ETA: 0s - loss: 2.4840 - accuracy: 0.0800WARNING:tensorflow:7 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x000001750CB72550> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 0s 28ms/step - loss: 2.3256 - accuracy: 0.1423 - val_loss: 2.2260 - val_accuracy: 0.1544\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/6 [====>.........................] - ETA: 0s - loss: 2.4408 - accuracy: 0.1200WARNING:tensorflow:7 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x000001750CE4E790> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 0s 24ms/step - loss: 2.3312 - accuracy: 0.1219 - val_loss: 2.2516 - val_accuracy: 0.2133\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/2 [==============>...............] - ETA: 0s - loss: 2.5300 - accuracy: 0.1000WARNING:tensorflow:7 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x000001750E1EF9D0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - 0s 65ms/step - loss: 2.5224 - accuracy: 0.0962 - val_loss: 2.5417 - val_accuracy: 0.0741\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/5 [=====>........................] - ETA: 0s - loss: 2.4268 - accuracy: 0.1100WARNING:tensorflow:7 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x000001750E5CFCA0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "5/5 [==============================] - 0s 23ms/step - loss: 2.3344 - accuracy: 0.1460 - val_loss: 2.1791 - val_accuracy: 0.2696\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/4 [======>.......................] - ETA: 0s - loss: 2.3169 - accuracy: 0.0700WARNING:tensorflow:7 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x000001750FAC0040> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - 0s 33ms/step - loss: 2.2812 - accuracy: 0.1136 - val_loss: 2.1869 - val_accuracy: 0.1429\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/3 [=========>....................] - ETA: 0s - loss: 2.3274 - accuracy: 0.1500WARNING:tensorflow:8 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x000001750FEA2160> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "3/3 [==============================] - 0s 46ms/step - loss: 2.3376 - accuracy: 0.1233 - val_loss: 2.3864 - val_accuracy: 0.0877\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/4 [======>.......................] - ETA: 0s - loss: 2.2462 - accuracy: 0.1800WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000175112583A0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - 1s 160ms/step - loss: 2.2009 - accuracy: 0.2216 - val_loss: 2.1267 - val_accuracy: 0.2791\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "2/2 [==============================] - ETA: 0s - loss: 2.3293 - accuracy: 0.1202WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x000001750CE4E3A0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - 0s 80ms/step - loss: 2.3293 - accuracy: 0.1202 - val_loss: 2.2156 - val_accuracy: 0.1739\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:5 out of the last 14 calls to <function Model.make_train_function.<locals>.train_function at 0x000001750B7BEEE0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/6 [====>.........................] - ETA: 0s - loss: 2.5285 - accuracy: 0.0500WARNING:tensorflow:9 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017509C95E50> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 0s 24ms/step - loss: 2.3893 - accuracy: 0.0651 - val_loss: 2.2446 - val_accuracy: 0.1259\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "8/8 [==============================] - ETA: 0s - loss: 2.2494 - accuracy: 0.1983WARNING:tensorflow:9 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017502B111F0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "8/8 [==============================] - 0s 21ms/step - loss: 2.2494 - accuracy: 0.1983 - val_loss: 2.1333 - val_accuracy: 0.2955\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/1 [==============================] - ETA: 0s - loss: 2.4760 - accuracy: 0.0290WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017512722DC0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/1 [==============================] - 0s 107ms/step - loss: 2.4760 - accuracy: 0.0290 - val_loss: 2.4728 - val_accuracy: 0.0556\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "3/3 [==============================] - ETA: 0s - loss: 2.3088 - accuracy: 0.1462WARNING:tensorflow:9 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017512C3E040> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3/3 [==============================] - 0s 54ms/step - loss: 2.3088 - accuracy: 0.1462 - val_loss: 2.2731 - val_accuracy: 0.1231\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/5 [=====>........................] - ETA: 0s - loss: 2.3405 - accuracy: 0.1100WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017513FF0280> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "5/5 [==============================] - 0s 23ms/step - loss: 2.2756 - accuracy: 0.1638 - val_loss: 2.1688 - val_accuracy: 0.2564\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "WARNING:tensorflow:5 out of the last 18 calls to <function Model.make_train_function.<locals>.train_function at 0x00000175140F8430> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/7 [===>..........................] - ETA: 0s - loss: 2.3148 - accuracy: 0.1600WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000175153714C0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "7/7 [==============================] - 0s 21ms/step - loss: 2.2588 - accuracy: 0.1599 - val_loss: 2.1515 - val_accuracy: 0.2625\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/6 [====>.........................] - ETA: 0s - loss: 2.3879 - accuracy: 0.0900WARNING:tensorflow:7 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017515669700> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 0s 19ms/step - loss: 2.3043 - accuracy: 0.1272 - val_loss: 2.1694 - val_accuracy: 0.1549\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5/5 [==============================] - ETA: 0s - loss: 2.3795 - accuracy: 0.0844WARNING:tensorflow:7 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017515A33940> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "5/5 [==============================] - 0s 33ms/step - loss: 2.3795 - accuracy: 0.0844 - val_loss: 2.3271 - val_accuracy: 0.1287\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/3 [=========>....................] - ETA: 0s - loss: 2.3220 - accuracy: 0.1300WARNING:tensorflow:7 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017516DE1B80> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "3/3 [==============================] - 0s 44ms/step - loss: 2.3090 - accuracy: 0.1149 - val_loss: 2.2115 - val_accuracy: 0.1757\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/3 [=========>....................] - ETA: 0s - loss: 2.3773 - accuracy: 0.0800WARNING:tensorflow:7 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000175173D0DC0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "3/3 [==============================] - 0s 37ms/step - loss: 2.3171 - accuracy: 0.1233 - val_loss: 2.3157 - val_accuracy: 0.1579\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/4 [======>.......................] - ETA: 0s - loss: 2.5104 - accuracy: 0.0900WARNING:tensorflow:7 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000175188DD160> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - 0s 28ms/step - loss: 2.3945 - accuracy: 0.1367 - val_loss: 2.2891 - val_accuracy: 0.2020\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/4 [======>.......................] - ETA: 0s - loss: 2.3803 - accuracy: 0.0700WARNING:tensorflow:8 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017518C89310> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - 0s 34ms/step - loss: 2.4151 - accuracy: 0.0593 - val_loss: 2.4207 - val_accuracy: 0.0538\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/4 [======>.......................] - ETA: 0s - loss: 2.3768 - accuracy: 0.1100WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017519ED1DC0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - 0s 28ms/step - loss: 2.3433 - accuracy: 0.1444 - val_loss: 2.2570 - val_accuracy: 0.1739\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/2 [==============>...............] - ETA: 0s - loss: 2.5158 - accuracy: 0.1000WARNING:tensorflow:9 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x000001751A3F3160> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - 0s 54ms/step - loss: 2.4916 - accuracy: 0.0872 - val_loss: 2.4153 - val_accuracy: 0.0909\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/6 [====>.........................] - ETA: 0s - loss: 2.3721 - accuracy: 0.0700WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x000001751B7A6280> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 0s 24ms/step - loss: 2.3159 - accuracy: 0.1124 - val_loss: 2.2255 - val_accuracy: 0.1716\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/5 [=====>........................] - ETA: 0s - loss: 2.4041 - accuracy: 0.0500WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x000001751BB534C0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "5/5 [==============================] - 0s 28ms/step - loss: 2.3553 - accuracy: 0.0771 - val_loss: 2.3138 - val_accuracy: 0.1759\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "6/6 [==============================] - ETA: 0s - loss: 2.3129 - accuracy: 0.1650WARNING:tensorflow:9 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x000001751CE1C700> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 1s 136ms/step - loss: 2.3129 - accuracy: 0.1650 - val_loss: 2.1975 - val_accuracy: 0.1875\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/2 [==============>...............] - ETA: 0s - loss: 2.3871 - accuracy: 0.1300WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000175189FE1F0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - 0s 68ms/step - loss: 2.3604 - accuracy: 0.1587 - val_loss: 2.4882 - val_accuracy: 0.0312\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/6 [====>.........................] - ETA: 0s - loss: 2.2612 - accuracy: 0.1600WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000175157C93A0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 0s 24ms/step - loss: 2.2547 - accuracy: 0.1790 - val_loss: 2.0953 - val_accuracy: 0.3333\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/4 [======>.......................] - ETA: 0s - loss: 2.3477 - accuracy: 0.1300WARNING:tensorflow:7 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x000001751287BDC0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "4/4 [==============================] - 0s 35ms/step - loss: 2.3208 - accuracy: 0.1378 - val_loss: 2.2404 - val_accuracy: 0.2151\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/2 [==============>...............] - ETA: 0s - loss: 2.3651 - accuracy: 0.1700WARNING:tensorflow:7 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x000001750FEA2280> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "2/2 [==============================] - 0s 53ms/step - loss: 2.3507 - accuracy: 0.1792 - val_loss: 2.3799 - val_accuracy: 0.2222\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/5 [=====>........................] - ETA: 0s - loss: 2.4879 - accuracy: 0.0600WARNING:tensorflow:8 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x000001751E657E50> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "5/5 [==============================] - 0s 34ms/step - loss: 2.4014 - accuracy: 0.0818 - val_loss: 2.3540 - val_accuracy: 0.0833\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/6 [====>.........................] - ETA: 0s - loss: 2.5677 - accuracy: 0.0500WARNING:tensorflow:8 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x000001751FB460D0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 0s 20ms/step - loss: 2.4643 - accuracy: 0.0521 - val_loss: 2.3377 - val_accuracy: 0.1000\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/1 [==============================] - ETA: 0s - loss: 2.3479 - accuracy: 0.1013WARNING:tensorflow:8 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x000001751FF09310> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/1 [==============================] - 0s 107ms/step - loss: 2.3479 - accuracy: 0.1013 - val_loss: 2.3055 - val_accuracy: 0.2000\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/6 [====>.........................] - ETA: 0s - loss: 2.3848 - accuracy: 0.0700WARNING:tensorflow:8 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000175212A4550> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 0s 20ms/step - loss: 2.2632 - accuracy: 0.1570 - val_loss: 2.1375 - val_accuracy: 0.2394\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "1/5 [=====>........................] - ETA: 0s - loss: 2.4073 - accuracy: 0.1300WARNING:tensorflow:8 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x000001752158D790> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "5/5 [==============================] - 0s 23ms/step - loss: 2.3567 - accuracy: 0.1440 - val_loss: 2.2444 - val_accuracy: 0.1984\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/6 [====>.........................] - ETA: 0s - loss: 2.3581 - accuracy: 0.1400WARNING:tensorflow:7 out of the last 11 calls to <function Model.make_test_function.<locals>.test_function at 0x00000175229379D0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "6/6 [==============================] - 0s 19ms/step - loss: 2.3017 - accuracy: 0.1261 - val_loss: 2.1359 - val_accuracy: 0.2617\n"
     ]
    }
   ],
   "source": [
    "learning_result_list = []\n",
    "for i in range(100):\n",
    "    model = models.Sequential()\n",
    "    model.add(layers.Conv2D(filters=6, kernel_size=(5,5), strides=1, activation='tanh', input_shape=(32, 32, 1)))\n",
    "    model.add(layers.AveragePooling2D(pool_size=2, strides=2))\n",
    "    model.add(layers.Conv2D(filters=16, kernel_size=(5,5), strides=1, activation='tanh'))\n",
    "    model.add(layers.AveragePooling2D(pool_size=2, strides=2))\n",
    "    model.add(layers.Flatten())\n",
    "    model.add(layers.Dense(120, activation='tanh'))\n",
    "    model.add(layers.Dense(84, activation='tanh'))\n",
    "    model.add(layers.Dense(10, activation='softmax'))\n",
    "    model.summary()\n",
    "    x_train, x_test, y_train, y_test = train_test_split(UE[i]['x_train'], UE[i]['y_train'], test_size=0.2, random_state=45)\n",
    "    model.compile(optimizer='SGD', loss='sparse_categorical_crossentropy', metrics=['accuracy'])\n",
    "    learning_result_list.append(model.fit(x_train, y_train, batch_size=100, epochs=1, validation_data=(x_test, y_test)))\n",
    "    tf.keras.backend.clear_session()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "buried-check",
   "metadata": {},
   "outputs": [],
   "source": [
    "UE_weights = []\n",
    "\n",
    "for model in learning_result_list:\n",
    "    layer_weights = {}\n",
    "    for x in model.model.layers:\n",
    "        if len(x.get_weights()) > 0:\n",
    "            layer_weights[x.name] = x.get_weights()\n",
    "    UE_weights.append(layer_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "altered-pound",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 28, 28, 6)         156       \n",
      "_________________________________________________________________\n",
      "average_pooling2d (AveragePo (None, 14, 14, 6)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 10, 10, 16)        2416      \n",
      "_________________________________________________________________\n",
      "average_pooling2d_1 (Average (None, 5, 5, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 400)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 120)               48120     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 84)                10164     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                850       \n",
      "=================================================================\n",
      "Total params: 61,706\n",
      "Trainable params: 61,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "server_model = models.Sequential()\n",
    "server_model.add(layers.Conv2D(filters=6, kernel_size=(5,5), strides=1, activation='tanh', input_shape=(32, 32, 1)))\n",
    "server_model.add(layers.AveragePooling2D(pool_size=2, strides=2))\n",
    "server_model.add(layers.Conv2D(filters=16, kernel_size=(5,5), strides=1, activation='tanh'))\n",
    "server_model.add(layers.AveragePooling2D(pool_size=2, strides=2))\n",
    "server_model.add(layers.Flatten())\n",
    "server_model.add(layers.Dense(120, activation='tanh'))\n",
    "server_model.add(layers.Dense(84, activation='tanh'))\n",
    "server_model.add(layers.Dense(10, activation='softmax'))\n",
    "server_model.summary()\n",
    "tf.keras.backend.clear_session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "interpreted-performer",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "conv2d\n",
      "conv2d_1\n",
      "dense\n",
      "dense_1\n",
      "dense_2\n"
     ]
    }
   ],
   "source": [
    "sum_weights = {}\n",
    "\n",
    "for i in range(len(list(UE_weights[0].keys()))):\n",
    "    weight_shape = [0]\n",
    "    bias_shape = [0]\n",
    "    print(list(UE_weights[0].keys())[i])\n",
    "    for dim in UE_weights[0][list(UE_weights[0].keys())[i]][0].shape:\n",
    "        weight_shape.append(dim)\n",
    "    for dim in UE_weights[0][list(UE_weights[0].keys())[i]][1].shape:\n",
    "        bias_shape.append(dim)\n",
    "    sum_weights.update({list(UE_weights[0].keys())[i]: {'weight': np.empty(weight_shape), 'bias':np.empty(bias_shape)}})\n",
    "    \n",
    "    for UE in UE_weights:\n",
    "        sum_weights[list(UE.keys())[i]]['weight'] = np.append(sum_weights[list(UE.keys())[i]]['weight'], [UE[list(UE.keys())[i]][0]], axis=0)\n",
    "        sum_weights[list(UE.keys())[i]]['bias'] = np.append(sum_weights[list(UE.keys())[i]]['bias'], [UE[list(UE.keys())[i]][1]], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "embedded-functionality",
   "metadata": {},
   "outputs": [],
   "source": [
    "for layer in sum_weights.keys():\n",
    "    for model_layer in server_model.layers:\n",
    "        if layer == model_layer.name:\n",
    "            model_layer.set_weights([np.mean(sum_weights[layer]['weight'], axis=0), np.mean(sum_weights[layer]['bias'], axis=0)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "political-cartoon",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:7 out of the last 12 calls to <function Model.make_test_function.<locals>.test_function at 0x0000017522A96D30> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "89/89 [==============================] - 0s 1ms/step - loss: 2.3026 - accuracy: 0.1063\n"
     ]
    }
   ],
   "source": [
    "server_model.compile(optimizer='SGD', loss='sparse_categorical_crossentropy', metrics=['accuracy'])\n",
    "result = server_model.evaluate(x=x_eval_dataset, y=y_eval_dataset, batch_size=128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "powered-horse",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test loss, test acc: [2.302578926086426, 0.10625331103801727]\n"
     ]
    }
   ],
   "source": [
    "print('test loss, test acc:', result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "prompt-logging",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(x_eval_dataset[300])\n",
    "print('true:',y_eval_dataset[300])\n",
    "print('prediction:',np.argmax(server_model.predict(np.expand_dims(x_eval_dataset[1], axis=0))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "practical-ireland",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gap(weights):\n",
    "    if len(weights.shape) == 4:\n",
    "        row = np.mean(weights, axis=1)\n",
    "        result = np.mean(row, axis=0)\n",
    "    elif len(weights.shape) == 2:\n",
    "        result = np.mean(weights, axis=0)\n",
    "    else:\n",
    "        raise print('가중치 잘못됨')\n",
    "    \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "molecular-sweden",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "native-characteristic",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "65"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(split_ue_group(UE_weights))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "invisible-wheat",
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_ue_group(UE_weights):\n",
    "    layers = UE_weights[0].keys()\n",
    "    concat_weight = {}\n",
    "    concat_mean_weight = {}\n",
    "\n",
    "    for layer in layers:\n",
    "        total = np.zeros((100, UE_weights[0][layer][0].shape[-2:][0], UE_weights[0][layer][0].shape[-2:][1]))\n",
    "        for i, UE in enumerate(UE_weights):\n",
    "            total[i] = gap(UE[layer][0])   \n",
    "        concat_weight[layer] = total\n",
    "\n",
    "    for layer in concat_weight.keys():\n",
    "        concat_mean_weight[layer] = np.mean(concat_weight[layer], axis=0)\n",
    "\n",
    "    UE_high_low = {}\n",
    "    for layer in concat_weight.keys():\n",
    "        true_cnt_list = []\n",
    "        for x in range(100):\n",
    "            high_low = concat_weight[layer][x] > concat_mean_weight[layer]\n",
    "            if len(high_low[high_low == True]) >= len(high_low[high_low == False]):\n",
    "                true_cnt_list.append(True)\n",
    "            else:\n",
    "                true_cnt_list.append(False)\n",
    "        UE_high_low[layer] = true_cnt_list\n",
    "\n",
    "    result = [0 for _ in range(100)]\n",
    "    for layer in UE_high_low.keys():\n",
    "        for i, x in enumerate(UE_high_low[layer]):\n",
    "            if x == True:\n",
    "                result[i] += 1\n",
    "                \n",
    "    true_ue_list = []\n",
    "    for i, x in enumerate(result):\n",
    "        if x >= math.ceil(len(UE_high_low.keys()) / 2):\n",
    "            true_ue_list.append(i)\n",
    "        \n",
    "    return true_ue_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "broke-usage",
   "metadata": {},
   "outputs": [],
   "source": [
    "layers = UE_weights[0].keys()\n",
    "concat_weight = {}\n",
    "concat_mean_weight = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "controlling-fishing",
   "metadata": {},
   "outputs": [],
   "source": [
    "for layer in layers:\n",
    "    print(layer)\n",
    "    total = np.zeros((100, UE_weights[0][layer][0].shape[-2:][0], UE_weights[0][layer][0].shape[-2:][1]))\n",
    "    for i, UE in enumerate(UE_weights):\n",
    "        print(gap(UE[layer][0]))\n",
    "        total[i] = gap(UE[layer][0])   \n",
    "    concat_weight[layer] = total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "first-israeli",
   "metadata": {},
   "outputs": [],
   "source": [
    "for layer in concat_weight.keys():\n",
    "    concat_mean_weight[layer] = np.mean(concat_weight[layer], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "saved-manhattan",
   "metadata": {},
   "outputs": [],
   "source": [
    "UE_high_low = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "coral-acrobat",
   "metadata": {},
   "outputs": [],
   "source": [
    "for layer in concat_weight.keys():\n",
    "    true_cnt_list = []\n",
    "    for x in range(100):\n",
    "        high_low = concat_weight[layer][x] > concat_mean_weight[layer]\n",
    "        if len(high_low[high_low == True]) >= len(high_low[high_low == False]):\n",
    "            true_cnt_list.append(True)\n",
    "        else:\n",
    "            true_cnt_list.append(False)\n",
    "    UE_high_low[layer] = true_cnt_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "robust-mounting",
   "metadata": {},
   "outputs": [],
   "source": [
    "result = [0 for _ in range(100)]\n",
    "for layer in UE_high_low.keys():\n",
    "    for i, x in enumerate(UE_high_low[layer]):\n",
    "        if x == True:\n",
    "            result[i] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "agricultural-sculpture",
   "metadata": {},
   "outputs": [],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "warming-grain",
   "metadata": {},
   "outputs": [],
   "source": [
    "true_ue_list = []\n",
    "for i, x in enumerate(result):\n",
    "    if x >= math.ceil(len(UE_high_low.keys()) / 2):\n",
    "        true_ue_list.append(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bulgarian-adoption",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(true_ue_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "taken-workplace",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tensor",
   "language": "python",
   "name": "tensor"
  },
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}