├── .gitignore ├── README.md ├── dataset ├── Data_hoda_full.mat ├── file └── mnist.pkl.gz ├── english_digit_classification.ipynb ├── farsi_digit_classification.ipynb ├── image_mod1.py ├── image_procesing2.ipynb ├── img ├── digit.png ├── dog1.jpeg ├── dog1_100.p.jpeg ├── dog1_200.p.jpeg ├── file └── git.png ├── mnist.pkl.gz ├── modules ├── data_utils.py ├── dataset.py ├── file ├── plot_utils.py └── utils.py └── read_image.ipynb /.gitignore: -------------------------------------------------------------------------------- 1 | # Built application files 2 | *.apk 3 | *.aar 4 | *.ap_ 5 | *.aab 6 | 7 | # Files for the ART/Dalvik VM 8 | *.dex 9 | 10 | # Java class files 11 | *.class 12 | 13 | # Generated files 14 | bin/ 15 | gen/ 16 | out/ 17 | # Uncomment the following line in case you need and you don't have the release build type files in your app 18 | # release/ 19 | 20 | # Gradle files 21 | .gradle/ 22 | build/ 23 | 24 | # Local configuration file (sdk path, etc) 25 | local.properties 26 | 27 | # Proguard folder generated by Eclipse 28 | proguard/ 29 | 30 | # Log Files 31 | *.log 32 | 33 | # Android Studio Navigation editor temp files 34 | .navigation/ 35 | 36 | # Android Studio captures folder 37 | captures/ 38 | 39 | # IntelliJ 40 | *.iml 41 | .idea/workspace.xml 42 | .idea/tasks.xml 43 | .idea/gradle.xml 44 | .idea/assetWizardSettings.xml 45 | .idea/dictionaries 46 | .idea/libraries 47 | # Android Studio 3 in .gitignore file. 48 | .idea/caches 49 | .idea/modules.xml 50 | # Comment next line if keeping position of elements in Navigation Editor is relevant for you 51 | .idea/navEditor.xml 52 | 53 | # Keystore files 54 | # Uncomment the following lines if you do not want to check your keystore files in. 55 | #*.jks 56 | #*.keystore 57 | 58 | # External native build folder generated in Android Studio 2.2 and later 59 | .externalNativeBuild 60 | .cxx/ 61 | 62 | # Google Services (e.g. APIs or Firebase) 63 | # google-services.json 64 | 65 | # Freeline 66 | freeline.py 67 | freeline/ 68 | freeline_project_description.json 69 | 70 | # fastlane 71 | fastlane/report.xml 72 | fastlane/Preview.html 73 | fastlane/screenshots 74 | fastlane/test_output 75 | fastlane/readme.md 76 | 77 | # Version control 78 | vcs.xml 79 | 80 | # lint 81 | lint/intermediates/ 82 | lint/generated/ 83 | lint/outputs/ 84 | lint/tmp/ 85 | # lint/reports/ 86 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # ImageProcessing 2 | 3 | [![keras](https://img.shields.io/badge/Keras%20-%23D00000?logo=keras)](https://keras.io/) 4 | [![TensorFlow 2.2](https://img.shields.io/badge/TensorFlow-2.2-FF6F00?logo=tensorflow)](https://github.com/tensorflow/tensorflow/releases/tag/v2.2.0) 5 | 6 | Recognition of handwritten characters is one of the most interesting topics in pattern recognition domain. For some scripts such as English, there are standard 7 | datasets available and reviewed, such as MNIST, CEDAR, CENPARMI. 8 | 9 | ## Persian digit dataset 10 | 11 | Although Farsi is a right to left script, its digits are written from left to right. Sample handwritten digits is shown in Persian, Arabic, Latin, Urdu. 12 | 13 | 14 | ![](https://github.com/Foroozani/ImageProcessing/blob/main/img/digit.png) 15 | 16 | ## HODA dataset 17 | 18 | This large dataset of Persian handwritten digits is called Hoda. Binary images of 102,352 digits were extracted from about 12,000 registration forms of two types, filled by B.Sc. and senior high school students. These forms were scanned at 200 dpi with a high speed scanner. A method for finding variety of handwritten digits in a typical dataset is proposed. Based on this method, training and test subsets are provided to facilitate sharing of results among researchers as well as performance comparison [Refrence to the dataset](https://www.sciencedirect.com/science/article/abs/pii/S0167865507000037). 19 | 20 | Here different apporach is examined to classify the images. I took both **Hoda** and **MNIST** dataset to study the case. 21 | 22 | ## MNIST dataset 23 | 24 | The MNIST, modified NIST, 5 dataset (LeCun et al.,1995) was extracted from the NIST datasets SD3 and SD7. Samples are normalized into 20 * 20 gray-scale images with aspect ratio reserved, and the normalized images are located in a 28 * 28 frame. The dataset is available from LeCun. Number of training and test samples are 60,000 and 10,000 respectively. 25 | -------------------------------------------------------------------------------- /dataset/Data_hoda_full.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Foroozani/ImageProcessing/31b286668e7a0852d976194e1af93f5532963d50/dataset/Data_hoda_full.mat -------------------------------------------------------------------------------- /dataset/file: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /dataset/mnist.pkl.gz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Foroozani/ImageProcessing/31b286668e7a0852d976194e1af93f5532963d50/dataset/mnist.pkl.gz -------------------------------------------------------------------------------- /farsi_digit_classification.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "
\n", 8 | "

Handwritten digit dataset in Farsi & English

\n", 9 | "

Image classification

\n", 10 | "
" 11 | ] 12 | }, 13 | { 14 | "cell_type": "markdown", 15 | "metadata": {}, 16 | "source": [ 17 | "# Handwritten Farsi digits\n", 18 | "\n", 19 | "\n", 20 | "Although Farsi is a right to left script, its digits are written from left to righ. HODA dataset has 102,352 digits which extracted from about 12,000 registration forms. \n", 21 | "\n" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 1, 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "#! pip install scikit-image # install scikit-image" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 2, 43 | "metadata": {}, 44 | "outputs": [], 45 | "source": [ 46 | "import numpy as np\n", 47 | "from scipy import io\n", 48 | "import matplotlib.pyplot as plt\n", 49 | "from skimage.transform import resize" 50 | ] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "metadata": {}, 55 | "source": [ 56 | "This dataset is written with Matlab, one can load it with \"scipy\"." 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": 3, 62 | "metadata": {}, 63 | "outputs": [], 64 | "source": [ 65 | "#load dataset\n", 66 | "dataset = io.loadmat('./dataset/Data_hoda_full.mat')" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 4, 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [ 75 | "#dataset\n" 76 | ] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "metadata": {}, 81 | "source": [ 82 | "This set has 60,000 digit for Training set and 20,000 digits for test set." 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": 5, 88 | "metadata": {}, 89 | "outputs": [], 90 | "source": [ 91 | "#test and training set split\n", 92 | "X_train_orginal = np.squeeze(dataset['Data'][:10000])\n", 93 | "y_train = np.squeeze(dataset['labels'][:10000])\n", 94 | "X_test_original = np.squeeze(dataset['Data'][10000:12000])\n", 95 | "y_test = np.squeeze(dataset['labels'][10000:12000])" 96 | ] 97 | }, 98 | { 99 | "cell_type": "markdown", 100 | "metadata": {}, 101 | "source": [ 102 | "\"squeeze\": Remove single-dimensional entries from the shape of an array." 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": 6, 108 | "metadata": {}, 109 | "outputs": [ 110 | { 111 | "data": { 112 | "image/png": "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\n", 113 | "text/plain": [ 114 | "
" 115 | ] 116 | }, 117 | "metadata": { 118 | "needs_background": "light" 119 | }, 120 | "output_type": "display_data" 121 | } 122 | ], 123 | "source": [ 124 | "plt.imshow(X_train_orginal[400], cmap='gray')\n", 125 | "plt.show()" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": 7, 131 | "metadata": {}, 132 | "outputs": [ 133 | { 134 | "data": { 135 | "image/png": "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\n", 136 | "text/plain": [ 137 | "
" 138 | ] 139 | }, 140 | "metadata": { 141 | "needs_background": "light" 142 | }, 143 | "output_type": "display_data" 144 | }, 145 | { 146 | "name": "stdout", 147 | "output_type": "stream", 148 | "text": [ 149 | "Label of 9000th image is: 9\n" 150 | ] 151 | } 152 | ], 153 | "source": [ 154 | "i=9000\n", 155 | "image = X_train_orginal[i]\n", 156 | "label = y_train[i]\n", 157 | "plt.imshow(image, cmap='gray')\n", 158 | "plt.show()\n", 159 | "print(\"Label of {}th image is: {}\".format(i, label))" 160 | ] 161 | }, 162 | { 163 | "cell_type": "code", 164 | "execution_count": 8, 165 | "metadata": {}, 166 | "outputs": [ 167 | { 168 | "data": { 169 | "text/plain": [ 170 | "(38, 18)" 171 | ] 172 | }, 173 | "execution_count": 8, 174 | "metadata": {}, 175 | "output_type": "execute_result" 176 | } 177 | ], 178 | "source": [ 179 | "image.shape" 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": 9, 185 | "metadata": {}, 186 | "outputs": [], 187 | "source": [ 188 | "#resize the image from ** to (5,5)\n", 189 | "X_train_5by5 = [resize(img, (5, 5)) for img in X_train_orginal]\n", 190 | "X_test_5by_5 = [resize(img, (5, 5)) for img in X_test_original]" 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": 10, 196 | "metadata": {}, 197 | "outputs": [ 198 | { 199 | "data": { 200 | "image/png": "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\n", 201 | "text/plain": [ 202 | "
" 203 | ] 204 | }, 205 | "metadata": { 206 | "needs_background": "light" 207 | }, 208 | "output_type": "display_data" 209 | } 210 | ], 211 | "source": [ 212 | "image = X_train_5by5[1]\n", 213 | "plt.imshow(image, cmap='gray')\n", 214 | "plt.show()" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": 11, 220 | "metadata": {}, 221 | "outputs": [ 222 | { 223 | "data": { 224 | "text/plain": [ 225 | "(5, 5)" 226 | ] 227 | }, 228 | "execution_count": 11, 229 | "metadata": {}, 230 | "output_type": "execute_result" 231 | } 232 | ], 233 | "source": [ 234 | "image.shape " 235 | ] 236 | }, 237 | { 238 | "cell_type": "code", 239 | "execution_count": 12, 240 | "metadata": {}, 241 | "outputs": [], 242 | "source": [ 243 | "#reshape\n", 244 | "X_train = [x.reshape(25) for x in X_train_5by5]\n", 245 | "X_test = [x.reshape(25) for x in X_test_5by_5]" 246 | ] 247 | }, 248 | { 249 | "cell_type": "code", 250 | "execution_count": 13, 251 | "metadata": {}, 252 | "outputs": [ 253 | { 254 | "data": { 255 | "text/plain": [ 256 | "(25,)" 257 | ] 258 | }, 259 | "execution_count": 13, 260 | "metadata": {}, 261 | "output_type": "execute_result" 262 | } 263 | ], 264 | "source": [ 265 | "X_train[0].shape" 266 | ] 267 | }, 268 | { 269 | "cell_type": "markdown", 270 | "metadata": {}, 271 | "source": [ 272 | "**n_neighbor is a hyperparameter which needs to be tuned.**" 273 | ] 274 | }, 275 | { 276 | "cell_type": "code", 277 | "execution_count": 14, 278 | "metadata": {}, 279 | "outputs": [], 280 | "source": [ 281 | "from sklearn.neighbors import KNeighborsClassifier\n", 282 | "from sklearn.model_selection import train_test_split" 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "execution_count": 15, 288 | "metadata": {}, 289 | "outputs": [ 290 | { 291 | "data": { 292 | "text/plain": [ 293 | "KNeighborsClassifier(n_neighbors=2)" 294 | ] 295 | }, 296 | "execution_count": 15, 297 | "metadata": {}, 298 | "output_type": "execute_result" 299 | } 300 | ], 301 | "source": [ 302 | "neigh = KNeighborsClassifier(n_neighbors=2)\n", 303 | "neigh.fit(X_train, y_train)" 304 | ] 305 | }, 306 | { 307 | "cell_type": "markdown", 308 | "metadata": {}, 309 | "source": [ 310 | "# Predictions and Evaluations\n", 311 | "\n", 312 | "Let's evaluate our **KNN** model!" 313 | ] 314 | }, 315 | { 316 | "cell_type": "code", 317 | "execution_count": 16, 318 | "metadata": {}, 319 | "outputs": [ 320 | { 321 | "name": "stdout", 322 | "output_type": "stream", 323 | "text": [ 324 | "Sample 24 is a 2, and you prediction is: 2.\n" 325 | ] 326 | } 327 | ], 328 | "source": [ 329 | "sample = 24\n", 330 | "\n", 331 | "X = [X_test[sample]]\n", 332 | "\n", 333 | "predicted_class = neigh.predict(X)\n", 334 | "actual_class = y_test[sample]\n", 335 | "\n", 336 | "print (\"Sample {} is a {}, and you prediction is: {}.\".format(sample, actual_class, predicted_class[0]))" 337 | ] 338 | }, 339 | { 340 | "cell_type": "code", 341 | "execution_count": 17, 342 | "metadata": {}, 343 | "outputs": [ 344 | { 345 | "name": "stdout", 346 | "output_type": "stream", 347 | "text": [ 348 | "[[0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]]\n" 349 | ] 350 | } 351 | ], 352 | "source": [ 353 | "print(neigh.predict_proba(X))" 354 | ] 355 | }, 356 | { 357 | "cell_type": "code", 358 | "execution_count": 18, 359 | "metadata": {}, 360 | "outputs": [ 361 | { 362 | "name": "stdout", 363 | "output_type": "stream", 364 | "text": [ 365 | "Predicted classes is:\n", 366 | "[5 8 8 ... 6 8 5]\n", 367 | "==========================================================================\n", 368 | "True classes is:\n", 369 | "[5 8 8 ... 6 8 5]\n" 370 | ] 371 | } 372 | ], 373 | "source": [ 374 | "y_pred = neigh.predict(X_test)\n", 375 | "\n", 376 | "\n", 377 | "print(\"Predicted classes is:\")\n", 378 | "print(y_pred)\n", 379 | "print(\"==========================================================================\")\n", 380 | "print(\"True classes is:\")\n", 381 | "print(y_test)" 382 | ] 383 | }, 384 | { 385 | "cell_type": "code", 386 | "execution_count": 19, 387 | "metadata": {}, 388 | "outputs": [ 389 | { 390 | "name": "stdout", 391 | "output_type": "stream", 392 | "text": [ 393 | "Accuracy is 96.350 %\n" 394 | ] 395 | } 396 | ], 397 | "source": [ 398 | "acc = neigh.score(X_test, y_test)\n", 399 | "print (\"Accuracy is %.3f %%\" %(acc*100))" 400 | ] 401 | }, 402 | { 403 | "cell_type": "code", 404 | "execution_count": 20, 405 | "metadata": {}, 406 | "outputs": [], 407 | "source": [ 408 | "from sklearn.metrics import classification_report,confusion_matrix" 409 | ] 410 | }, 411 | { 412 | "cell_type": "code", 413 | "execution_count": 21, 414 | "metadata": {}, 415 | "outputs": [ 416 | { 417 | "name": "stdout", 418 | "output_type": "stream", 419 | "text": [ 420 | "[[216 9 0 0 0 1 0 1 0 0]\n", 421 | " [ 3 187 1 0 0 0 0 0 0 0]\n", 422 | " [ 0 0 189 11 4 0 1 1 0 1]\n", 423 | " [ 0 0 0 166 20 1 0 0 0 0]\n", 424 | " [ 0 0 0 3 176 1 0 0 0 0]\n", 425 | " [ 0 0 0 0 0 181 1 0 0 0]\n", 426 | " [ 0 0 0 0 0 0 206 0 0 6]\n", 427 | " [ 1 0 2 0 0 0 0 204 0 0]\n", 428 | " [ 0 0 0 0 0 1 0 0 202 0]\n", 429 | " [ 0 1 0 0 0 0 1 0 2 200]]\n" 430 | ] 431 | } 432 | ], 433 | "source": [ 434 | "print(confusion_matrix(y_pred,y_test))" 435 | ] 436 | }, 437 | { 438 | "cell_type": "code", 439 | "execution_count": 22, 440 | "metadata": {}, 441 | "outputs": [], 442 | "source": [ 443 | "error_rate = []\n", 444 | "\n", 445 | "# Will take some time\n", 446 | "for i in range(1,40):\n", 447 | " \n", 448 | " knn = KNeighborsClassifier(n_neighbors=i)\n", 449 | " knn.fit(X_train,y_train)\n", 450 | " pred_i = knn.predict(X_test)\n", 451 | " error_rate.append(np.mean(pred_i != y_test))" 452 | ] 453 | }, 454 | { 455 | "cell_type": "code", 456 | "execution_count": 23, 457 | "metadata": {}, 458 | "outputs": [ 459 | { 460 | "data": { 461 | "text/plain": [ 462 | "Text(0, 0.5, 'Error Rate')" 463 | ] 464 | }, 465 | "execution_count": 23, 466 | "metadata": {}, 467 | "output_type": "execute_result" 468 | }, 469 | { 470 | "data": { 471 | "image/png": "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\n", 472 | "text/plain": [ 473 | "
" 474 | ] 475 | }, 476 | "metadata": { 477 | "needs_background": "light" 478 | }, 479 | "output_type": "display_data" 480 | } 481 | ], 482 | "source": [ 483 | "plt.figure(figsize=(10,6))\n", 484 | "plt.plot(range(1,40),error_rate,color='blue', linestyle='dashed', marker='o',\n", 485 | " markerfacecolor='red', markersize=10)\n", 486 | "plt.title('Error Rate vs. K Value')\n", 487 | "plt.xlabel('K')\n", 488 | "plt.ylabel('Error Rate')" 489 | ] 490 | }, 491 | { 492 | "cell_type": "markdown", 493 | "metadata": {}, 494 | "source": [ 495 | "Here we can see that that after arouns K>4 the error rate just tends to hover around 0.02 Let's retrain the model with that and check the classification report! K=4 is the minimum" 496 | ] 497 | }, 498 | { 499 | "cell_type": "code", 500 | "execution_count": 24, 501 | "metadata": {}, 502 | "outputs": [ 503 | { 504 | "name": "stdout", 505 | "output_type": "stream", 506 | "text": [ 507 | "WITH K=4\n", 508 | "\n", 509 | "\n", 510 | "[[217 2 0 0 0 0 0 1 0 0]\n", 511 | " [ 5 191 0 0 0 0 0 0 0 1]\n", 512 | " [ 0 1 188 1 0 0 0 2 0 0]\n", 513 | " [ 0 0 6 171 3 0 0 0 0 0]\n", 514 | " [ 0 0 3 12 185 0 0 0 0 0]\n", 515 | " [ 1 0 0 0 1 181 1 0 1 0]\n", 516 | " [ 0 0 1 0 0 1 206 0 0 1]\n", 517 | " [ 1 0 0 0 0 0 0 205 0 0]\n", 518 | " [ 0 0 0 0 0 0 1 0 201 2]\n", 519 | " [ 0 0 1 0 0 0 4 0 0 202]]\n", 520 | "\n", 521 | "\n", 522 | " precision recall f1-score support\n", 523 | "\n", 524 | " 0 0.97 0.99 0.98 220\n", 525 | " 1 0.98 0.97 0.98 197\n", 526 | " 2 0.94 0.98 0.96 192\n", 527 | " 3 0.93 0.95 0.94 180\n", 528 | " 4 0.98 0.93 0.95 200\n", 529 | " 5 0.99 0.98 0.99 185\n", 530 | " 6 0.97 0.99 0.98 209\n", 531 | " 7 0.99 1.00 0.99 206\n", 532 | " 8 1.00 0.99 0.99 204\n", 533 | " 9 0.98 0.98 0.98 207\n", 534 | "\n", 535 | " accuracy 0.97 2000\n", 536 | " macro avg 0.97 0.97 0.97 2000\n", 537 | "weighted avg 0.97 0.97 0.97 2000\n", 538 | "\n" 539 | ] 540 | } 541 | ], 542 | "source": [ 543 | "# NOW WITH K=4\n", 544 | "knn = KNeighborsClassifier(n_neighbors=4)\n", 545 | "\n", 546 | "knn.fit(X_train,y_train)\n", 547 | "pred = knn.predict(X_test)\n", 548 | "\n", 549 | "print('WITH K=4')\n", 550 | "print('\\n')\n", 551 | "print(confusion_matrix(y_test,pred))\n", 552 | "print('\\n')\n", 553 | "print(classification_report(y_test,pred))\n", 554 | "\n" 555 | ] 556 | }, 557 | { 558 | "cell_type": "markdown", 559 | "metadata": {}, 560 | "source": [ 561 | "**Improved!**" 562 | ] 563 | }, 564 | { 565 | "cell_type": "markdown", 566 | "metadata": {}, 567 | "source": [ 568 | "# Neural Networks " 569 | ] 570 | }, 571 | { 572 | "cell_type": "code", 573 | "execution_count": 26, 574 | "metadata": {}, 575 | "outputs": [], 576 | "source": [ 577 | "import keras\n", 578 | "from keras.models import Sequential\n", 579 | "from keras.layers import Dense, Activation\n", 580 | "import numpy as np" 581 | ] 582 | }, 583 | { 584 | "cell_type": "code", 585 | "execution_count": 27, 586 | "metadata": {}, 587 | "outputs": [], 588 | "source": [ 589 | "np.random.seed(123) # for reproducibility" 590 | ] 591 | }, 592 | { 593 | "cell_type": "code", 594 | "execution_count": 30, 595 | "metadata": {}, 596 | "outputs": [ 597 | { 598 | "data": { 599 | "text/plain": [ 600 | "array([0.54941176, 0.48784314, 0.0172549 , 0.14980392, 0.48196078,\n", 601 | " 0.79176471, 0.2627451 , 0.40862745, 0.72117647, 0.3172549 ,\n", 602 | " 0.38235294, 0.65686275, 0.8627451 , 0.27058824, 0.00980392,\n", 603 | " 0.02235294, 0.62313725, 0.41960784, 0.00862745, 0. ,\n", 604 | " 0.06901961, 0.69058824, 0.09843137, 0. , 0. ])" 605 | ] 606 | }, 607 | "execution_count": 30, 608 | "metadata": {}, 609 | "output_type": "execute_result" 610 | } 611 | ], 612 | "source": [ 613 | "X_train[0]" 614 | ] 615 | }, 616 | { 617 | "cell_type": "code", 618 | "execution_count": 31, 619 | "metadata": {}, 620 | "outputs": [], 621 | "source": [ 622 | "def print_data_info(x_train, y_train, x_test, y_test):\n", 623 | " #Check data Type\n", 624 | " print (\"\\ttype(x_train): {}\".format(type(x_train)))\n", 625 | " print (\"\\ttype(y_train): {}\".format(type(y_train)))\n", 626 | "\n", 627 | " #check data Shape\n", 628 | " print (\"\\tx_train.shape: {}\".format(np.shape(x_train)))\n", 629 | " print (\"\\ty_train.shape: {}\".format(np.shape(y_train)))\n", 630 | " print (\"\\tx_test.shape: {}\".format(np.shape(x_test)))\n", 631 | " print (\"\\ty_test.shape: {}\".format(np.shape(y_test)))\n", 632 | "\n", 633 | " #sample data\n", 634 | " print (\"\\ty_train[0]: {}\".format(y_train[0]))" 635 | ] 636 | }, 637 | { 638 | "cell_type": "code", 639 | "execution_count": 34, 640 | "metadata": {}, 641 | "outputs": [], 642 | "source": [ 643 | "# Preprocess input data for Keras. \n", 644 | "x_train = np.array(X_train)\n", 645 | "y_train = keras.utils.to_categorical(y_train, num_classes=10)\n", 646 | "x_test = np.array(X_test)\n", 647 | "y_test = keras.utils.to_categorical(y_test, num_classes=10)" 648 | ] 649 | }, 650 | { 651 | "cell_type": "code", 652 | "execution_count": 35, 653 | "metadata": {}, 654 | "outputs": [ 655 | { 656 | "name": "stdout", 657 | "output_type": "stream", 658 | "text": [ 659 | "Before Preprocessing:\n", 660 | "\ttype(x_train): \n", 661 | "\ttype(y_train): \n", 662 | "\tx_train.shape: (10000, 25)\n", 663 | "\ty_train.shape: (10000, 10)\n", 664 | "\tx_test.shape: (2000, 25)\n", 665 | "\ty_test.shape: (2000, 10)\n", 666 | "\ty_train[0]: [0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]\n", 667 | "After Preprocessing:\n", 668 | "\ttype(x_train): \n", 669 | "\ttype(y_train): \n", 670 | "\tx_train.shape: (10000, 25)\n", 671 | "\ty_train.shape: (10000, 10)\n", 672 | "\tx_test.shape: (2000, 25)\n", 673 | "\ty_test.shape: (2000, 10)\n", 674 | "\ty_train[0]: [0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]\n" 675 | ] 676 | } 677 | ], 678 | "source": [ 679 | "print(\"Before Preprocessing:\")\n", 680 | "print_data_info(X_train, y_train, X_test, y_test)\n", 681 | "print(\"After Preprocessing:\")\n", 682 | "print_data_info(X_train, y_train, x_test, y_test)" 683 | ] 684 | }, 685 | { 686 | "cell_type": "code", 687 | "execution_count": 36, 688 | "metadata": {}, 689 | "outputs": [], 690 | "source": [ 691 | "x_train = x_train.astype('float32')\n", 692 | "x_test = x_test.astype('float32')\n", 693 | "x_train /= 255\n", 694 | "x_test /= 255" 695 | ] 696 | }, 697 | { 698 | "cell_type": "markdown", 699 | "metadata": {}, 700 | "source": [ 701 | "## model architecture" 702 | ] 703 | }, 704 | { 705 | "cell_type": "code", 706 | "execution_count": 37, 707 | "metadata": {}, 708 | "outputs": [ 709 | { 710 | "name": "stdout", 711 | "output_type": "stream", 712 | "text": [ 713 | "Model: \"sequential_1\"\n", 714 | "_________________________________________________________________\n", 715 | "Layer (type) Output Shape Param # \n", 716 | "=================================================================\n", 717 | "dense_1 (Dense) (None, 64) 1664 \n", 718 | "_________________________________________________________________\n", 719 | "dense_2 (Dense) (None, 10) 650 \n", 720 | "=================================================================\n", 721 | "Total params: 2,314\n", 722 | "Trainable params: 2,314\n", 723 | "Non-trainable params: 0\n", 724 | "_________________________________________________________________\n" 725 | ] 726 | } 727 | ], 728 | "source": [ 729 | "model = Sequential()\n", 730 | "model.add(Dense(64, activation='relu', input_dim=25))\n", 731 | "model.add(Dense(10, activation='softmax'))\n", 732 | "model.summary()" 733 | ] 734 | }, 735 | { 736 | "cell_type": "code", 737 | "execution_count": 38, 738 | "metadata": {}, 739 | "outputs": [], 740 | "source": [ 741 | "# compile the model \n", 742 | "model.compile(loss='categorical_crossentropy',\n", 743 | " optimizer='adam',\n", 744 | " metrics=['accuracy'])" 745 | ] 746 | }, 747 | { 748 | "cell_type": "code", 749 | "execution_count": 41, 750 | "metadata": {}, 751 | "outputs": [ 752 | { 753 | "name": "stdout", 754 | "output_type": "stream", 755 | "text": [ 756 | "Train on 8000 samples, validate on 2000 samples\n", 757 | "Epoch 1/300\n", 758 | "8000/8000 [==============================] - 0s 7us/step - loss: 1.4295 - accuracy: 0.7126 - val_loss: 1.4243 - val_accuracy: 0.7070\n", 759 | "Epoch 2/300\n", 760 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.4046 - accuracy: 0.7157 - val_loss: 1.4014 - val_accuracy: 0.7010\n", 761 | "Epoch 3/300\n", 762 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.3810 - accuracy: 0.7179 - val_loss: 1.3782 - val_accuracy: 0.7085\n", 763 | "Epoch 4/300\n", 764 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.3575 - accuracy: 0.7230 - val_loss: 1.3545 - val_accuracy: 0.7125\n", 765 | "Epoch 5/300\n", 766 | "8000/8000 [==============================] - 0s 7us/step - loss: 1.3354 - accuracy: 0.7259 - val_loss: 1.3342 - val_accuracy: 0.7135\n", 767 | "Epoch 6/300\n", 768 | "8000/8000 [==============================] - 0s 7us/step - loss: 1.3141 - accuracy: 0.7259 - val_loss: 1.3112 - val_accuracy: 0.7265\n", 769 | "Epoch 7/300\n", 770 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.2933 - accuracy: 0.7301 - val_loss: 1.2904 - val_accuracy: 0.7240\n", 771 | "Epoch 8/300\n", 772 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.2728 - accuracy: 0.7339 - val_loss: 1.2700 - val_accuracy: 0.7260\n", 773 | "Epoch 9/300\n", 774 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.2538 - accuracy: 0.7344 - val_loss: 1.2507 - val_accuracy: 0.7260\n", 775 | "Epoch 10/300\n", 776 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.2351 - accuracy: 0.7410 - val_loss: 1.2326 - val_accuracy: 0.7305\n", 777 | "Epoch 11/300\n", 778 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.2165 - accuracy: 0.7409 - val_loss: 1.2134 - val_accuracy: 0.7250\n", 779 | "Epoch 12/300\n", 780 | "8000/8000 [==============================] - 0s 7us/step - loss: 1.1991 - accuracy: 0.7406 - val_loss: 1.1965 - val_accuracy: 0.7260\n", 781 | "Epoch 13/300\n", 782 | "8000/8000 [==============================] - 0s 7us/step - loss: 1.1815 - accuracy: 0.7490 - val_loss: 1.1822 - val_accuracy: 0.7350\n", 783 | "Epoch 14/300\n", 784 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.1645 - accuracy: 0.7462 - val_loss: 1.1616 - val_accuracy: 0.7350\n", 785 | "Epoch 15/300\n", 786 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.1477 - accuracy: 0.7536 - val_loss: 1.1460 - val_accuracy: 0.7350\n", 787 | "Epoch 16/300\n", 788 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.1320 - accuracy: 0.7538 - val_loss: 1.1285 - val_accuracy: 0.7370\n", 789 | "Epoch 17/300\n", 790 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.1164 - accuracy: 0.7586 - val_loss: 1.1153 - val_accuracy: 0.7375\n", 791 | "Epoch 18/300\n", 792 | "8000/8000 [==============================] - 0s 7us/step - loss: 1.1014 - accuracy: 0.7604 - val_loss: 1.0993 - val_accuracy: 0.7415\n", 793 | "Epoch 19/300\n", 794 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.0863 - accuracy: 0.7602 - val_loss: 1.0845 - val_accuracy: 0.7540\n", 795 | "Epoch 20/300\n", 796 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.0724 - accuracy: 0.7638 - val_loss: 1.0715 - val_accuracy: 0.7490\n", 797 | "Epoch 21/300\n", 798 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.0578 - accuracy: 0.7679 - val_loss: 1.0557 - val_accuracy: 0.7500\n", 799 | "Epoch 22/300\n", 800 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.0433 - accuracy: 0.7706 - val_loss: 1.0442 - val_accuracy: 0.7445\n", 801 | "Epoch 23/300\n", 802 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.0301 - accuracy: 0.7679 - val_loss: 1.0272 - val_accuracy: 0.7590\n", 803 | "Epoch 24/300\n", 804 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.0165 - accuracy: 0.7746 - val_loss: 1.0131 - val_accuracy: 0.7645\n", 805 | "Epoch 25/300\n", 806 | "8000/8000 [==============================] - 0s 6us/step - loss: 1.0036 - accuracy: 0.7755 - val_loss: 1.0016 - val_accuracy: 0.7595\n", 807 | "Epoch 26/300\n", 808 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.9910 - accuracy: 0.7778 - val_loss: 0.9901 - val_accuracy: 0.7585\n", 809 | "Epoch 27/300\n", 810 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.9783 - accuracy: 0.7786 - val_loss: 0.9749 - val_accuracy: 0.7660\n", 811 | "Epoch 28/300\n", 812 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.9662 - accuracy: 0.7805 - val_loss: 0.9641 - val_accuracy: 0.7685\n", 813 | "Epoch 29/300\n", 814 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.9541 - accuracy: 0.7843 - val_loss: 0.9515 - val_accuracy: 0.7725\n", 815 | "Epoch 30/300\n", 816 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.9425 - accuracy: 0.7839 - val_loss: 0.9387 - val_accuracy: 0.7710\n", 817 | "Epoch 31/300\n", 818 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.9310 - accuracy: 0.7850 - val_loss: 0.9272 - val_accuracy: 0.7795\n", 819 | "Epoch 32/300\n", 820 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.9188 - accuracy: 0.7876 - val_loss: 0.9157 - val_accuracy: 0.7855\n", 821 | "Epoch 33/300\n", 822 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.9083 - accuracy: 0.7936 - val_loss: 0.9056 - val_accuracy: 0.7800\n", 823 | "Epoch 34/300\n", 824 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.8969 - accuracy: 0.7904 - val_loss: 0.8942 - val_accuracy: 0.7855\n", 825 | "Epoch 35/300\n", 826 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.8866 - accuracy: 0.7949 - val_loss: 0.8833 - val_accuracy: 0.7810\n", 827 | "Epoch 36/300\n", 828 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.8756 - accuracy: 0.7970 - val_loss: 0.8725 - val_accuracy: 0.7880\n", 829 | "Epoch 37/300\n", 830 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.8649 - accuracy: 0.7972 - val_loss: 0.8621 - val_accuracy: 0.7870\n", 831 | "Epoch 38/300\n", 832 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.8547 - accuracy: 0.7975 - val_loss: 0.8512 - val_accuracy: 0.7900\n", 833 | "Epoch 39/300\n", 834 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.8455 - accuracy: 0.8019 - val_loss: 0.8437 - val_accuracy: 0.7880\n", 835 | "Epoch 40/300\n", 836 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.8351 - accuracy: 0.7994 - val_loss: 0.8315 - val_accuracy: 0.7950\n", 837 | "Epoch 41/300\n", 838 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.8252 - accuracy: 0.8052 - val_loss: 0.8226 - val_accuracy: 0.7955\n", 839 | "Epoch 42/300\n", 840 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.8157 - accuracy: 0.8044 - val_loss: 0.8117 - val_accuracy: 0.8000\n", 841 | "Epoch 43/300\n", 842 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.8066 - accuracy: 0.8071 - val_loss: 0.8037 - val_accuracy: 0.7985\n", 843 | "Epoch 44/300\n", 844 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.7972 - accuracy: 0.8071 - val_loss: 0.7946 - val_accuracy: 0.8000\n", 845 | "Epoch 45/300\n", 846 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.7884 - accuracy: 0.8104 - val_loss: 0.7853 - val_accuracy: 0.8055\n", 847 | "Epoch 46/300\n", 848 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.7800 - accuracy: 0.8114 - val_loss: 0.7754 - val_accuracy: 0.8090\n", 849 | "Epoch 47/300\n", 850 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.7713 - accuracy: 0.8138 - val_loss: 0.7676 - val_accuracy: 0.8085\n", 851 | "Epoch 48/300\n", 852 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.7620 - accuracy: 0.8146 - val_loss: 0.7586 - val_accuracy: 0.8130\n", 853 | "Epoch 49/300\n", 854 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.7533 - accuracy: 0.8146 - val_loss: 0.7517 - val_accuracy: 0.8110\n", 855 | "Epoch 50/300\n", 856 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.7453 - accuracy: 0.8145 - val_loss: 0.7411 - val_accuracy: 0.8180\n", 857 | "Epoch 51/300\n", 858 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.7371 - accuracy: 0.8199 - val_loss: 0.7328 - val_accuracy: 0.8210\n", 859 | "Epoch 52/300\n", 860 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.7300 - accuracy: 0.8216 - val_loss: 0.7272 - val_accuracy: 0.8135\n", 861 | "Epoch 53/300\n", 862 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.7217 - accuracy: 0.8210 - val_loss: 0.7172 - val_accuracy: 0.8205\n", 863 | "Epoch 54/300\n", 864 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.7147 - accuracy: 0.8223 - val_loss: 0.7092 - val_accuracy: 0.8230\n", 865 | "Epoch 55/300\n", 866 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.7068 - accuracy: 0.8245 - val_loss: 0.7028 - val_accuracy: 0.8220\n", 867 | "Epoch 56/300\n", 868 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.6994 - accuracy: 0.8254 - val_loss: 0.6942 - val_accuracy: 0.8280\n" 869 | ] 870 | }, 871 | { 872 | "name": "stdout", 873 | "output_type": "stream", 874 | "text": [ 875 | "Epoch 57/300\n", 876 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.6918 - accuracy: 0.8282 - val_loss: 0.6883 - val_accuracy: 0.8245\n", 877 | "Epoch 58/300\n", 878 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.6852 - accuracy: 0.8282 - val_loss: 0.6802 - val_accuracy: 0.8295\n", 879 | "Epoch 59/300\n", 880 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.6774 - accuracy: 0.8313 - val_loss: 0.6732 - val_accuracy: 0.8280\n", 881 | "Epoch 60/300\n", 882 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.6712 - accuracy: 0.8342 - val_loss: 0.6673 - val_accuracy: 0.8310\n", 883 | "Epoch 61/300\n", 884 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.6643 - accuracy: 0.8330 - val_loss: 0.6600 - val_accuracy: 0.8325\n", 885 | "Epoch 62/300\n", 886 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.6572 - accuracy: 0.8356 - val_loss: 0.6535 - val_accuracy: 0.8320\n", 887 | "Epoch 63/300\n", 888 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.6513 - accuracy: 0.8375 - val_loss: 0.6477 - val_accuracy: 0.8325\n", 889 | "Epoch 64/300\n", 890 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.6451 - accuracy: 0.8359 - val_loss: 0.6400 - val_accuracy: 0.8395\n", 891 | "Epoch 65/300\n", 892 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.6381 - accuracy: 0.8399 - val_loss: 0.6354 - val_accuracy: 0.8345\n", 893 | "Epoch 66/300\n", 894 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.6324 - accuracy: 0.8394 - val_loss: 0.6279 - val_accuracy: 0.8375\n", 895 | "Epoch 67/300\n", 896 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.6263 - accuracy: 0.8416 - val_loss: 0.6207 - val_accuracy: 0.8430\n", 897 | "Epoch 68/300\n", 898 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.6199 - accuracy: 0.8430 - val_loss: 0.6142 - val_accuracy: 0.8465\n", 899 | "Epoch 69/300\n", 900 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.6151 - accuracy: 0.8431 - val_loss: 0.6096 - val_accuracy: 0.8405\n", 901 | "Epoch 70/300\n", 902 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.6093 - accuracy: 0.8443 - val_loss: 0.6031 - val_accuracy: 0.8470\n", 903 | "Epoch 71/300\n", 904 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.6033 - accuracy: 0.8454 - val_loss: 0.5976 - val_accuracy: 0.8430\n", 905 | "Epoch 72/300\n", 906 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.5977 - accuracy: 0.8472 - val_loss: 0.5914 - val_accuracy: 0.8485\n", 907 | "Epoch 73/300\n", 908 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.5923 - accuracy: 0.8464 - val_loss: 0.5865 - val_accuracy: 0.8480\n", 909 | "Epoch 74/300\n", 910 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5868 - accuracy: 0.8478 - val_loss: 0.5813 - val_accuracy: 0.8450\n", 911 | "Epoch 75/300\n", 912 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5817 - accuracy: 0.8487 - val_loss: 0.5750 - val_accuracy: 0.8545\n", 913 | "Epoch 76/300\n", 914 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5766 - accuracy: 0.8508 - val_loss: 0.5701 - val_accuracy: 0.8510\n", 915 | "Epoch 77/300\n", 916 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5716 - accuracy: 0.8524 - val_loss: 0.5674 - val_accuracy: 0.8520\n", 917 | "Epoch 78/300\n", 918 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5667 - accuracy: 0.8508 - val_loss: 0.5590 - val_accuracy: 0.8550\n", 919 | "Epoch 79/300\n", 920 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5608 - accuracy: 0.8531 - val_loss: 0.5545 - val_accuracy: 0.8570\n", 921 | "Epoch 80/300\n", 922 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5568 - accuracy: 0.8547 - val_loss: 0.5523 - val_accuracy: 0.8585\n", 923 | "Epoch 81/300\n", 924 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5527 - accuracy: 0.8555 - val_loss: 0.5458 - val_accuracy: 0.8530\n", 925 | "Epoch 82/300\n", 926 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5476 - accuracy: 0.8554 - val_loss: 0.5400 - val_accuracy: 0.8590\n", 927 | "Epoch 83/300\n", 928 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5427 - accuracy: 0.8571 - val_loss: 0.5386 - val_accuracy: 0.8585\n", 929 | "Epoch 84/300\n", 930 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5391 - accuracy: 0.8564 - val_loss: 0.5313 - val_accuracy: 0.8645\n", 931 | "Epoch 85/300\n", 932 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5340 - accuracy: 0.8575 - val_loss: 0.5277 - val_accuracy: 0.8575\n", 933 | "Epoch 86/300\n", 934 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5306 - accuracy: 0.8591 - val_loss: 0.5220 - val_accuracy: 0.8640\n", 935 | "Epoch 87/300\n", 936 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5257 - accuracy: 0.8612 - val_loss: 0.5198 - val_accuracy: 0.8660\n", 937 | "Epoch 88/300\n", 938 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5213 - accuracy: 0.8606 - val_loss: 0.5144 - val_accuracy: 0.8685\n", 939 | "Epoch 89/300\n", 940 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5176 - accuracy: 0.8618 - val_loss: 0.5099 - val_accuracy: 0.8640\n", 941 | "Epoch 90/300\n", 942 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5129 - accuracy: 0.8622 - val_loss: 0.5054 - val_accuracy: 0.8685\n", 943 | "Epoch 91/300\n", 944 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5093 - accuracy: 0.8619 - val_loss: 0.5021 - val_accuracy: 0.8710\n", 945 | "Epoch 92/300\n", 946 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5055 - accuracy: 0.8651 - val_loss: 0.4970 - val_accuracy: 0.8705\n", 947 | "Epoch 93/300\n", 948 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.5014 - accuracy: 0.8645 - val_loss: 0.4939 - val_accuracy: 0.8750\n", 949 | "Epoch 94/300\n", 950 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4981 - accuracy: 0.8645 - val_loss: 0.4905 - val_accuracy: 0.8730\n", 951 | "Epoch 95/300\n", 952 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4943 - accuracy: 0.8664 - val_loss: 0.4867 - val_accuracy: 0.8730\n", 953 | "Epoch 96/300\n", 954 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4904 - accuracy: 0.8665 - val_loss: 0.4834 - val_accuracy: 0.8765\n", 955 | "Epoch 97/300\n", 956 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4877 - accuracy: 0.8660 - val_loss: 0.4788 - val_accuracy: 0.8755\n", 957 | "Epoch 98/300\n", 958 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4838 - accuracy: 0.8673 - val_loss: 0.4764 - val_accuracy: 0.8760\n", 959 | "Epoch 99/300\n", 960 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4799 - accuracy: 0.8675 - val_loss: 0.4722 - val_accuracy: 0.8790\n", 961 | "Epoch 100/300\n", 962 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4765 - accuracy: 0.8681 - val_loss: 0.4677 - val_accuracy: 0.8770\n", 963 | "Epoch 101/300\n", 964 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4734 - accuracy: 0.8691 - val_loss: 0.4659 - val_accuracy: 0.8780\n", 965 | "Epoch 102/300\n", 966 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4701 - accuracy: 0.8704 - val_loss: 0.4616 - val_accuracy: 0.8810\n", 967 | "Epoch 103/300\n", 968 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4670 - accuracy: 0.8711 - val_loss: 0.4580 - val_accuracy: 0.8795\n", 969 | "Epoch 104/300\n", 970 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4633 - accuracy: 0.8730 - val_loss: 0.4553 - val_accuracy: 0.8795\n", 971 | "Epoch 105/300\n", 972 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4601 - accuracy: 0.8726 - val_loss: 0.4513 - val_accuracy: 0.8835\n", 973 | "Epoch 106/300\n", 974 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4575 - accuracy: 0.8729 - val_loss: 0.4494 - val_accuracy: 0.8810\n", 975 | "Epoch 107/300\n", 976 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4544 - accuracy: 0.8748 - val_loss: 0.4454 - val_accuracy: 0.8825\n", 977 | "Epoch 108/300\n", 978 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.4516 - accuracy: 0.8741 - val_loss: 0.4437 - val_accuracy: 0.8835\n", 979 | "Epoch 109/300\n", 980 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.4487 - accuracy: 0.8752 - val_loss: 0.4408 - val_accuracy: 0.8835\n", 981 | "Epoch 110/300\n", 982 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4452 - accuracy: 0.8759 - val_loss: 0.4376 - val_accuracy: 0.8865\n", 983 | "Epoch 111/300\n", 984 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4433 - accuracy: 0.8773 - val_loss: 0.4329 - val_accuracy: 0.8835\n", 985 | "Epoch 112/300\n", 986 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4395 - accuracy: 0.8750 - val_loss: 0.4319 - val_accuracy: 0.8865\n", 987 | "Epoch 113/300\n" 988 | ] 989 | }, 990 | { 991 | "name": "stdout", 992 | "output_type": "stream", 993 | "text": [ 994 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4372 - accuracy: 0.8764 - val_loss: 0.4292 - val_accuracy: 0.8860\n", 995 | "Epoch 114/300\n", 996 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4344 - accuracy: 0.8784 - val_loss: 0.4263 - val_accuracy: 0.8895\n", 997 | "Epoch 115/300\n", 998 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4320 - accuracy: 0.8785 - val_loss: 0.4221 - val_accuracy: 0.8890\n", 999 | "Epoch 116/300\n", 1000 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.4293 - accuracy: 0.8790 - val_loss: 0.4224 - val_accuracy: 0.8890\n", 1001 | "Epoch 117/300\n", 1002 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4261 - accuracy: 0.8791 - val_loss: 0.4181 - val_accuracy: 0.8910\n", 1003 | "Epoch 118/300\n", 1004 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4239 - accuracy: 0.8791 - val_loss: 0.4162 - val_accuracy: 0.8935\n", 1005 | "Epoch 119/300\n", 1006 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4218 - accuracy: 0.8804 - val_loss: 0.4125 - val_accuracy: 0.8890\n", 1007 | "Epoch 120/300\n", 1008 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4190 - accuracy: 0.8817 - val_loss: 0.4105 - val_accuracy: 0.8915\n", 1009 | "Epoch 121/300\n", 1010 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4163 - accuracy: 0.8806 - val_loss: 0.4078 - val_accuracy: 0.8945\n", 1011 | "Epoch 122/300\n", 1012 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.4142 - accuracy: 0.8817 - val_loss: 0.4047 - val_accuracy: 0.8910\n", 1013 | "Epoch 123/300\n", 1014 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.4119 - accuracy: 0.8834 - val_loss: 0.4031 - val_accuracy: 0.8925\n", 1015 | "Epoch 124/300\n", 1016 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.4091 - accuracy: 0.8823 - val_loss: 0.4001 - val_accuracy: 0.8915\n", 1017 | "Epoch 125/300\n", 1018 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.4068 - accuracy: 0.8835 - val_loss: 0.4005 - val_accuracy: 0.8890\n", 1019 | "Epoch 126/300\n", 1020 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.4058 - accuracy: 0.8836 - val_loss: 0.3951 - val_accuracy: 0.8950\n", 1021 | "Epoch 127/300\n", 1022 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.4025 - accuracy: 0.8841 - val_loss: 0.3947 - val_accuracy: 0.8890\n", 1023 | "Epoch 128/300\n", 1024 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.4016 - accuracy: 0.8855 - val_loss: 0.3928 - val_accuracy: 0.8940\n", 1025 | "Epoch 129/300\n", 1026 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3976 - accuracy: 0.8842 - val_loss: 0.3886 - val_accuracy: 0.8965\n", 1027 | "Epoch 130/300\n", 1028 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3954 - accuracy: 0.8874 - val_loss: 0.3867 - val_accuracy: 0.8925\n", 1029 | "Epoch 131/300\n", 1030 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3938 - accuracy: 0.8870 - val_loss: 0.3857 - val_accuracy: 0.8925\n", 1031 | "Epoch 132/300\n", 1032 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3922 - accuracy: 0.8875 - val_loss: 0.3823 - val_accuracy: 0.8975\n", 1033 | "Epoch 133/300\n", 1034 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3902 - accuracy: 0.8859 - val_loss: 0.3795 - val_accuracy: 0.8965\n", 1035 | "Epoch 134/300\n", 1036 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3880 - accuracy: 0.8882 - val_loss: 0.3789 - val_accuracy: 0.8970\n", 1037 | "Epoch 135/300\n", 1038 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3855 - accuracy: 0.8903 - val_loss: 0.3792 - val_accuracy: 0.8945\n", 1039 | "Epoch 136/300\n", 1040 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3843 - accuracy: 0.8891 - val_loss: 0.3740 - val_accuracy: 0.8980\n", 1041 | "Epoch 137/300\n", 1042 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3812 - accuracy: 0.8906 - val_loss: 0.3726 - val_accuracy: 0.8955\n", 1043 | "Epoch 138/300\n", 1044 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3798 - accuracy: 0.8913 - val_loss: 0.3707 - val_accuracy: 0.8985\n", 1045 | "Epoch 139/300\n", 1046 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3778 - accuracy: 0.8914 - val_loss: 0.3704 - val_accuracy: 0.9015\n", 1047 | "Epoch 140/300\n", 1048 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3763 - accuracy: 0.8907 - val_loss: 0.3670 - val_accuracy: 0.8990\n", 1049 | "Epoch 141/300\n", 1050 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3745 - accuracy: 0.8904 - val_loss: 0.3654 - val_accuracy: 0.9000\n", 1051 | "Epoch 142/300\n", 1052 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3727 - accuracy: 0.8911 - val_loss: 0.3646 - val_accuracy: 0.9020\n", 1053 | "Epoch 143/300\n", 1054 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3709 - accuracy: 0.8903 - val_loss: 0.3603 - val_accuracy: 0.9010\n", 1055 | "Epoch 144/300\n", 1056 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3685 - accuracy: 0.8925 - val_loss: 0.3594 - val_accuracy: 0.8995\n", 1057 | "Epoch 145/300\n", 1058 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3672 - accuracy: 0.8911 - val_loss: 0.3576 - val_accuracy: 0.8995\n", 1059 | "Epoch 146/300\n", 1060 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3651 - accuracy: 0.8944 - val_loss: 0.3560 - val_accuracy: 0.9030\n", 1061 | "Epoch 147/300\n", 1062 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3630 - accuracy: 0.8947 - val_loss: 0.3536 - val_accuracy: 0.9015\n", 1063 | "Epoch 148/300\n", 1064 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3623 - accuracy: 0.8945 - val_loss: 0.3520 - val_accuracy: 0.9020\n", 1065 | "Epoch 149/300\n", 1066 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3602 - accuracy: 0.8929 - val_loss: 0.3526 - val_accuracy: 0.9045\n", 1067 | "Epoch 150/300\n", 1068 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3584 - accuracy: 0.8963 - val_loss: 0.3500 - val_accuracy: 0.9050\n", 1069 | "Epoch 151/300\n", 1070 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3574 - accuracy: 0.8959 - val_loss: 0.3470 - val_accuracy: 0.9020\n", 1071 | "Epoch 152/300\n", 1072 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3555 - accuracy: 0.8967 - val_loss: 0.3463 - val_accuracy: 0.9035\n", 1073 | "Epoch 153/300\n", 1074 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3538 - accuracy: 0.8971 - val_loss: 0.3445 - val_accuracy: 0.9025\n", 1075 | "Epoch 154/300\n", 1076 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3520 - accuracy: 0.8967 - val_loss: 0.3448 - val_accuracy: 0.9035\n", 1077 | "Epoch 155/300\n", 1078 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3508 - accuracy: 0.8981 - val_loss: 0.3420 - val_accuracy: 0.9060\n", 1079 | "Epoch 156/300\n", 1080 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3491 - accuracy: 0.8961 - val_loss: 0.3410 - val_accuracy: 0.9060\n", 1081 | "Epoch 157/300\n", 1082 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3482 - accuracy: 0.8970 - val_loss: 0.3385 - val_accuracy: 0.9050\n", 1083 | "Epoch 158/300\n", 1084 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3466 - accuracy: 0.8967 - val_loss: 0.3363 - val_accuracy: 0.9035\n", 1085 | "Epoch 159/300\n", 1086 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3448 - accuracy: 0.8996 - val_loss: 0.3357 - val_accuracy: 0.9035\n", 1087 | "Epoch 160/300\n", 1088 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3443 - accuracy: 0.8995 - val_loss: 0.3342 - val_accuracy: 0.9030\n", 1089 | "Epoch 161/300\n", 1090 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3421 - accuracy: 0.8985 - val_loss: 0.3314 - val_accuracy: 0.9040\n", 1091 | "Epoch 162/300\n", 1092 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3404 - accuracy: 0.8984 - val_loss: 0.3304 - val_accuracy: 0.9045\n", 1093 | "Epoch 163/300\n", 1094 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3386 - accuracy: 0.9006 - val_loss: 0.3292 - val_accuracy: 0.9090\n", 1095 | "Epoch 164/300\n", 1096 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3375 - accuracy: 0.9003 - val_loss: 0.3281 - val_accuracy: 0.9055\n", 1097 | "Epoch 165/300\n", 1098 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3358 - accuracy: 0.8980 - val_loss: 0.3272 - val_accuracy: 0.9045\n", 1099 | "Epoch 166/300\n", 1100 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3347 - accuracy: 0.9013 - val_loss: 0.3251 - val_accuracy: 0.9050\n", 1101 | "Epoch 167/300\n", 1102 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3333 - accuracy: 0.9013 - val_loss: 0.3241 - val_accuracy: 0.9065\n", 1103 | "Epoch 168/300\n", 1104 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3320 - accuracy: 0.9020 - val_loss: 0.3236 - val_accuracy: 0.9050\n" 1105 | ] 1106 | }, 1107 | { 1108 | "name": "stdout", 1109 | "output_type": "stream", 1110 | "text": [ 1111 | "Epoch 169/300\n", 1112 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3305 - accuracy: 0.9021 - val_loss: 0.3238 - val_accuracy: 0.9095\n", 1113 | "Epoch 170/300\n", 1114 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3290 - accuracy: 0.9028 - val_loss: 0.3232 - val_accuracy: 0.9060\n", 1115 | "Epoch 171/300\n", 1116 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3287 - accuracy: 0.9041 - val_loss: 0.3191 - val_accuracy: 0.9060\n", 1117 | "Epoch 172/300\n", 1118 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3270 - accuracy: 0.9021 - val_loss: 0.3197 - val_accuracy: 0.9065\n", 1119 | "Epoch 173/300\n", 1120 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3264 - accuracy: 0.9031 - val_loss: 0.3156 - val_accuracy: 0.9065\n", 1121 | "Epoch 174/300\n", 1122 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3245 - accuracy: 0.9040 - val_loss: 0.3151 - val_accuracy: 0.9070\n", 1123 | "Epoch 175/300\n", 1124 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3231 - accuracy: 0.9049 - val_loss: 0.3140 - val_accuracy: 0.9070\n", 1125 | "Epoch 176/300\n", 1126 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3222 - accuracy: 0.9044 - val_loss: 0.3120 - val_accuracy: 0.9065\n", 1127 | "Epoch 177/300\n", 1128 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3205 - accuracy: 0.9045 - val_loss: 0.3146 - val_accuracy: 0.9070\n", 1129 | "Epoch 178/300\n", 1130 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3195 - accuracy: 0.9043 - val_loss: 0.3111 - val_accuracy: 0.9085\n", 1131 | "Epoch 179/300\n", 1132 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3184 - accuracy: 0.9061 - val_loss: 0.3097 - val_accuracy: 0.9075\n", 1133 | "Epoch 180/300\n", 1134 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3173 - accuracy: 0.9045 - val_loss: 0.3086 - val_accuracy: 0.9060\n", 1135 | "Epoch 181/300\n", 1136 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3159 - accuracy: 0.9064 - val_loss: 0.3075 - val_accuracy: 0.9085\n", 1137 | "Epoch 182/300\n", 1138 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.3147 - accuracy: 0.9066 - val_loss: 0.3060 - val_accuracy: 0.9115\n", 1139 | "Epoch 183/300\n", 1140 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.3136 - accuracy: 0.9055 - val_loss: 0.3048 - val_accuracy: 0.9070\n", 1141 | "Epoch 184/300\n", 1142 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.3128 - accuracy: 0.9069 - val_loss: 0.3042 - val_accuracy: 0.9100\n", 1143 | "Epoch 185/300\n", 1144 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.3118 - accuracy: 0.9071 - val_loss: 0.3036 - val_accuracy: 0.9110\n", 1145 | "Epoch 186/300\n", 1146 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.3108 - accuracy: 0.9072 - val_loss: 0.3017 - val_accuracy: 0.9100\n", 1147 | "Epoch 187/300\n", 1148 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.3095 - accuracy: 0.9080 - val_loss: 0.2998 - val_accuracy: 0.9105\n", 1149 | "Epoch 188/300\n", 1150 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.3079 - accuracy: 0.9080 - val_loss: 0.2992 - val_accuracy: 0.9095\n", 1151 | "Epoch 189/300\n", 1152 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.3069 - accuracy: 0.9084 - val_loss: 0.2981 - val_accuracy: 0.9095\n", 1153 | "Epoch 190/300\n", 1154 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.3068 - accuracy: 0.9076 - val_loss: 0.2983 - val_accuracy: 0.9065\n", 1155 | "Epoch 191/300\n", 1156 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.3054 - accuracy: 0.9085 - val_loss: 0.2982 - val_accuracy: 0.9105\n", 1157 | "Epoch 192/300\n", 1158 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.3043 - accuracy: 0.9106 - val_loss: 0.2963 - val_accuracy: 0.9130\n", 1159 | "Epoch 193/300\n", 1160 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.3033 - accuracy: 0.9103 - val_loss: 0.2955 - val_accuracy: 0.9105\n", 1161 | "Epoch 194/300\n", 1162 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.3020 - accuracy: 0.9097 - val_loss: 0.2929 - val_accuracy: 0.9115\n", 1163 | "Epoch 195/300\n", 1164 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3013 - accuracy: 0.9107 - val_loss: 0.2931 - val_accuracy: 0.9115\n", 1165 | "Epoch 196/300\n", 1166 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.3001 - accuracy: 0.9106 - val_loss: 0.2919 - val_accuracy: 0.9100\n", 1167 | "Epoch 197/300\n", 1168 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2991 - accuracy: 0.9107 - val_loss: 0.2904 - val_accuracy: 0.9110\n", 1169 | "Epoch 198/300\n", 1170 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2981 - accuracy: 0.9121 - val_loss: 0.2901 - val_accuracy: 0.9105\n", 1171 | "Epoch 199/300\n", 1172 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2975 - accuracy: 0.9133 - val_loss: 0.2891 - val_accuracy: 0.9115\n", 1173 | "Epoch 200/300\n", 1174 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2959 - accuracy: 0.9121 - val_loss: 0.2919 - val_accuracy: 0.9145\n", 1175 | "Epoch 201/300\n", 1176 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2955 - accuracy: 0.9136 - val_loss: 0.2865 - val_accuracy: 0.9105\n", 1177 | "Epoch 202/300\n", 1178 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2945 - accuracy: 0.9126 - val_loss: 0.2865 - val_accuracy: 0.9155\n", 1179 | "Epoch 203/300\n", 1180 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2935 - accuracy: 0.9139 - val_loss: 0.2848 - val_accuracy: 0.9140\n", 1181 | "Epoch 204/300\n", 1182 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2927 - accuracy: 0.9129 - val_loss: 0.2848 - val_accuracy: 0.9115\n", 1183 | "Epoch 205/300\n", 1184 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2917 - accuracy: 0.9126 - val_loss: 0.2823 - val_accuracy: 0.9145\n", 1185 | "Epoch 206/300\n", 1186 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2909 - accuracy: 0.9145 - val_loss: 0.2844 - val_accuracy: 0.9165\n", 1187 | "Epoch 207/300\n", 1188 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2900 - accuracy: 0.9141 - val_loss: 0.2819 - val_accuracy: 0.9175\n", 1189 | "Epoch 208/300\n", 1190 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2894 - accuracy: 0.9146 - val_loss: 0.2814 - val_accuracy: 0.9160\n", 1191 | "Epoch 209/300\n", 1192 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2883 - accuracy: 0.9144 - val_loss: 0.2800 - val_accuracy: 0.9175\n", 1193 | "Epoch 210/300\n", 1194 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2871 - accuracy: 0.9154 - val_loss: 0.2805 - val_accuracy: 0.9205\n", 1195 | "Epoch 211/300\n", 1196 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2861 - accuracy: 0.9155 - val_loss: 0.2811 - val_accuracy: 0.9170\n", 1197 | "Epoch 212/300\n", 1198 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2861 - accuracy: 0.9158 - val_loss: 0.2781 - val_accuracy: 0.9180\n", 1199 | "Epoch 213/300\n", 1200 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2849 - accuracy: 0.9147 - val_loss: 0.2787 - val_accuracy: 0.9205\n", 1201 | "Epoch 214/300\n", 1202 | "8000/8000 [==============================] - ETA: 0s - loss: 0.2300 - accuracy: 0.92 - 0s 6us/step - loss: 0.2843 - accuracy: 0.9159 - val_loss: 0.2766 - val_accuracy: 0.9150\n", 1203 | "Epoch 215/300\n", 1204 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2833 - accuracy: 0.9168 - val_loss: 0.2758 - val_accuracy: 0.9195\n", 1205 | "Epoch 216/300\n", 1206 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2821 - accuracy: 0.9169 - val_loss: 0.2760 - val_accuracy: 0.9175\n", 1207 | "Epoch 217/300\n", 1208 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2820 - accuracy: 0.9164 - val_loss: 0.2771 - val_accuracy: 0.9225\n", 1209 | "Epoch 218/300\n", 1210 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2811 - accuracy: 0.9168 - val_loss: 0.2732 - val_accuracy: 0.9170\n", 1211 | "Epoch 219/300\n", 1212 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2807 - accuracy: 0.9156 - val_loss: 0.2728 - val_accuracy: 0.9215\n", 1213 | "Epoch 220/300\n", 1214 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2799 - accuracy: 0.9166 - val_loss: 0.2727 - val_accuracy: 0.9215\n", 1215 | "Epoch 221/300\n", 1216 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2786 - accuracy: 0.9165 - val_loss: 0.2709 - val_accuracy: 0.9200\n", 1217 | "Epoch 222/300\n", 1218 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2776 - accuracy: 0.9179 - val_loss: 0.2704 - val_accuracy: 0.9175\n", 1219 | "Epoch 223/300\n", 1220 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2765 - accuracy: 0.9181 - val_loss: 0.2701 - val_accuracy: 0.9220\n", 1221 | "Epoch 224/300\n" 1222 | ] 1223 | }, 1224 | { 1225 | "name": "stdout", 1226 | "output_type": "stream", 1227 | "text": [ 1228 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2763 - accuracy: 0.9184 - val_loss: 0.2691 - val_accuracy: 0.9195\n", 1229 | "Epoch 225/300\n", 1230 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2753 - accuracy: 0.9190 - val_loss: 0.2686 - val_accuracy: 0.9175\n", 1231 | "Epoch 226/300\n", 1232 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2747 - accuracy: 0.9183 - val_loss: 0.2682 - val_accuracy: 0.9225\n", 1233 | "Epoch 227/300\n", 1234 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2739 - accuracy: 0.9199 - val_loss: 0.2663 - val_accuracy: 0.9215\n", 1235 | "Epoch 228/300\n", 1236 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2737 - accuracy: 0.9194 - val_loss: 0.2659 - val_accuracy: 0.9215\n", 1237 | "Epoch 229/300\n", 1238 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2728 - accuracy: 0.9194 - val_loss: 0.2666 - val_accuracy: 0.9210\n", 1239 | "Epoch 230/300\n", 1240 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2726 - accuracy: 0.9199 - val_loss: 0.2649 - val_accuracy: 0.9215\n", 1241 | "Epoch 231/300\n", 1242 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.2714 - accuracy: 0.9197 - val_loss: 0.2649 - val_accuracy: 0.9220\n", 1243 | "Epoch 232/300\n", 1244 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2705 - accuracy: 0.9200 - val_loss: 0.2654 - val_accuracy: 0.9285\n", 1245 | "Epoch 233/300\n", 1246 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2698 - accuracy: 0.9211 - val_loss: 0.2624 - val_accuracy: 0.9190\n", 1247 | "Epoch 234/300\n", 1248 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2690 - accuracy: 0.9208 - val_loss: 0.2625 - val_accuracy: 0.9235\n", 1249 | "Epoch 235/300\n", 1250 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2684 - accuracy: 0.9200 - val_loss: 0.2609 - val_accuracy: 0.9220\n", 1251 | "Epoch 236/300\n", 1252 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2681 - accuracy: 0.9216 - val_loss: 0.2613 - val_accuracy: 0.9205\n", 1253 | "Epoch 237/300\n", 1254 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2672 - accuracy: 0.9224 - val_loss: 0.2595 - val_accuracy: 0.9205\n", 1255 | "Epoch 238/300\n", 1256 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2673 - accuracy: 0.9224 - val_loss: 0.2597 - val_accuracy: 0.9295\n", 1257 | "Epoch 239/300\n", 1258 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2657 - accuracy: 0.9222 - val_loss: 0.2607 - val_accuracy: 0.9250\n", 1259 | "Epoch 240/300\n", 1260 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2658 - accuracy: 0.9218 - val_loss: 0.2584 - val_accuracy: 0.9270\n", 1261 | "Epoch 241/300\n", 1262 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2640 - accuracy: 0.9235 - val_loss: 0.2579 - val_accuracy: 0.9320\n", 1263 | "Epoch 242/300\n", 1264 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2641 - accuracy: 0.9219 - val_loss: 0.2561 - val_accuracy: 0.9250\n", 1265 | "Epoch 243/300\n", 1266 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2635 - accuracy: 0.9222 - val_loss: 0.2553 - val_accuracy: 0.9270\n", 1267 | "Epoch 244/300\n", 1268 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2625 - accuracy: 0.9225 - val_loss: 0.2566 - val_accuracy: 0.9320\n", 1269 | "Epoch 245/300\n", 1270 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2621 - accuracy: 0.9235 - val_loss: 0.2572 - val_accuracy: 0.9260\n", 1271 | "Epoch 246/300\n", 1272 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2618 - accuracy: 0.9221 - val_loss: 0.2563 - val_accuracy: 0.9255\n", 1273 | "Epoch 247/300\n", 1274 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2610 - accuracy: 0.9244 - val_loss: 0.2554 - val_accuracy: 0.9315\n", 1275 | "Epoch 248/300\n", 1276 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2600 - accuracy: 0.9236 - val_loss: 0.2552 - val_accuracy: 0.9310\n", 1277 | "Epoch 249/300\n", 1278 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2598 - accuracy: 0.9236 - val_loss: 0.2539 - val_accuracy: 0.9310\n", 1279 | "Epoch 250/300\n", 1280 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2585 - accuracy: 0.9233 - val_loss: 0.2534 - val_accuracy: 0.9250\n", 1281 | "Epoch 251/300\n", 1282 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2586 - accuracy: 0.9239 - val_loss: 0.2521 - val_accuracy: 0.9310\n", 1283 | "Epoch 252/300\n", 1284 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2574 - accuracy: 0.9254 - val_loss: 0.2518 - val_accuracy: 0.9275\n", 1285 | "Epoch 253/300\n", 1286 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2578 - accuracy: 0.9230 - val_loss: 0.2512 - val_accuracy: 0.9285\n", 1287 | "Epoch 254/300\n", 1288 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2561 - accuracy: 0.9259 - val_loss: 0.2512 - val_accuracy: 0.9280\n", 1289 | "Epoch 255/300\n", 1290 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2558 - accuracy: 0.9254 - val_loss: 0.2496 - val_accuracy: 0.9335\n", 1291 | "Epoch 256/300\n", 1292 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2556 - accuracy: 0.9246 - val_loss: 0.2503 - val_accuracy: 0.9330\n", 1293 | "Epoch 257/300\n", 1294 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2546 - accuracy: 0.9256 - val_loss: 0.2492 - val_accuracy: 0.9315\n", 1295 | "Epoch 258/300\n", 1296 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2542 - accuracy: 0.9249 - val_loss: 0.2496 - val_accuracy: 0.9300\n", 1297 | "Epoch 259/300\n", 1298 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2538 - accuracy: 0.9254 - val_loss: 0.2496 - val_accuracy: 0.9265\n", 1299 | "Epoch 260/300\n", 1300 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2531 - accuracy: 0.9275 - val_loss: 0.2487 - val_accuracy: 0.9290\n", 1301 | "Epoch 261/300\n", 1302 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.2522 - accuracy: 0.9268 - val_loss: 0.2487 - val_accuracy: 0.9300\n", 1303 | "Epoch 262/300\n", 1304 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2520 - accuracy: 0.9260 - val_loss: 0.2468 - val_accuracy: 0.9330\n", 1305 | "Epoch 263/300\n", 1306 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2511 - accuracy: 0.9275 - val_loss: 0.2456 - val_accuracy: 0.9325\n", 1307 | "Epoch 264/300\n", 1308 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2515 - accuracy: 0.9269 - val_loss: 0.2465 - val_accuracy: 0.9315\n", 1309 | "Epoch 265/300\n", 1310 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2510 - accuracy: 0.9266 - val_loss: 0.2458 - val_accuracy: 0.9320\n", 1311 | "Epoch 266/300\n", 1312 | "8000/8000 [==============================] - 0s 7us/step - loss: 0.2501 - accuracy: 0.9268 - val_loss: 0.2433 - val_accuracy: 0.9335\n", 1313 | "Epoch 267/300\n", 1314 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2494 - accuracy: 0.9286 - val_loss: 0.2441 - val_accuracy: 0.9320\n", 1315 | "Epoch 268/300\n", 1316 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2489 - accuracy: 0.9274 - val_loss: 0.2433 - val_accuracy: 0.9325\n", 1317 | "Epoch 269/300\n", 1318 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2487 - accuracy: 0.9268 - val_loss: 0.2441 - val_accuracy: 0.9305\n", 1319 | "Epoch 270/300\n", 1320 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2475 - accuracy: 0.9280 - val_loss: 0.2430 - val_accuracy: 0.9320\n", 1321 | "Epoch 271/300\n", 1322 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2470 - accuracy: 0.9286 - val_loss: 0.2415 - val_accuracy: 0.9335\n", 1323 | "Epoch 272/300\n", 1324 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2467 - accuracy: 0.9271 - val_loss: 0.2428 - val_accuracy: 0.9300\n", 1325 | "Epoch 273/300\n", 1326 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2471 - accuracy: 0.9285 - val_loss: 0.2415 - val_accuracy: 0.9305\n", 1327 | "Epoch 274/300\n", 1328 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2458 - accuracy: 0.9290 - val_loss: 0.2406 - val_accuracy: 0.9320\n", 1329 | "Epoch 275/300\n", 1330 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2454 - accuracy: 0.9280 - val_loss: 0.2432 - val_accuracy: 0.9320\n", 1331 | "Epoch 276/300\n", 1332 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2452 - accuracy: 0.9290 - val_loss: 0.2403 - val_accuracy: 0.9315\n", 1333 | "Epoch 277/300\n", 1334 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2445 - accuracy: 0.9285 - val_loss: 0.2404 - val_accuracy: 0.9330\n", 1335 | "Epoch 278/300\n", 1336 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2439 - accuracy: 0.9285 - val_loss: 0.2407 - val_accuracy: 0.9335\n", 1337 | "Epoch 279/300\n", 1338 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2434 - accuracy: 0.9289 - val_loss: 0.2376 - val_accuracy: 0.9340\n" 1339 | ] 1340 | }, 1341 | { 1342 | "name": "stdout", 1343 | "output_type": "stream", 1344 | "text": [ 1345 | "Epoch 280/300\n", 1346 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2430 - accuracy: 0.9279 - val_loss: 0.2381 - val_accuracy: 0.9320\n", 1347 | "Epoch 281/300\n", 1348 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2424 - accuracy: 0.9304 - val_loss: 0.2369 - val_accuracy: 0.9355\n", 1349 | "Epoch 282/300\n", 1350 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2429 - accuracy: 0.9298 - val_loss: 0.2391 - val_accuracy: 0.9335\n", 1351 | "Epoch 283/300\n", 1352 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2417 - accuracy: 0.9311 - val_loss: 0.2375 - val_accuracy: 0.9350\n", 1353 | "Epoch 284/300\n", 1354 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2416 - accuracy: 0.9287 - val_loss: 0.2371 - val_accuracy: 0.9335\n", 1355 | "Epoch 285/300\n", 1356 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2406 - accuracy: 0.9302 - val_loss: 0.2370 - val_accuracy: 0.9330\n", 1357 | "Epoch 286/300\n", 1358 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2405 - accuracy: 0.9298 - val_loss: 0.2352 - val_accuracy: 0.9345\n", 1359 | "Epoch 287/300\n", 1360 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2401 - accuracy: 0.9310 - val_loss: 0.2373 - val_accuracy: 0.9325\n", 1361 | "Epoch 288/300\n", 1362 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2391 - accuracy: 0.9301 - val_loss: 0.2343 - val_accuracy: 0.9315\n", 1363 | "Epoch 289/300\n", 1364 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2383 - accuracy: 0.9311 - val_loss: 0.2369 - val_accuracy: 0.9340\n", 1365 | "Epoch 290/300\n", 1366 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2390 - accuracy: 0.9299 - val_loss: 0.2346 - val_accuracy: 0.9340\n", 1367 | "Epoch 291/300\n", 1368 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2381 - accuracy: 0.9314 - val_loss: 0.2322 - val_accuracy: 0.9360\n", 1369 | "Epoch 292/300\n", 1370 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2379 - accuracy: 0.9302 - val_loss: 0.2336 - val_accuracy: 0.9335\n", 1371 | "Epoch 293/300\n", 1372 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2375 - accuracy: 0.9312 - val_loss: 0.2330 - val_accuracy: 0.9350\n", 1373 | "Epoch 294/300\n", 1374 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2368 - accuracy: 0.9315 - val_loss: 0.2326 - val_accuracy: 0.9355\n", 1375 | "Epoch 295/300\n", 1376 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2365 - accuracy: 0.9315 - val_loss: 0.2325 - val_accuracy: 0.9325\n", 1377 | "Epoch 296/300\n", 1378 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2362 - accuracy: 0.9301 - val_loss: 0.2330 - val_accuracy: 0.9320\n", 1379 | "Epoch 297/300\n", 1380 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2356 - accuracy: 0.9320 - val_loss: 0.2316 - val_accuracy: 0.9355\n", 1381 | "Epoch 298/300\n", 1382 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2347 - accuracy: 0.9304 - val_loss: 0.2292 - val_accuracy: 0.9350\n", 1383 | "Epoch 299/300\n", 1384 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2346 - accuracy: 0.9337 - val_loss: 0.2300 - val_accuracy: 0.9350\n", 1385 | "Epoch 300/300\n", 1386 | "8000/8000 [==============================] - 0s 6us/step - loss: 0.2340 - accuracy: 0.9319 - val_loss: 0.2306 - val_accuracy: 0.9355\n" 1387 | ] 1388 | }, 1389 | { 1390 | "data": { 1391 | "text/plain": [ 1392 | "" 1393 | ] 1394 | }, 1395 | "execution_count": 41, 1396 | "metadata": {}, 1397 | "output_type": "execute_result" 1398 | } 1399 | ], 1400 | "source": [ 1401 | "model.fit(x_train, y_train,\n", 1402 | " epochs=300,\n", 1403 | " batch_size=128, validation_split=0.2)" 1404 | ] 1405 | }, 1406 | { 1407 | "cell_type": "code", 1408 | "execution_count": 42, 1409 | "metadata": {}, 1410 | "outputs": [ 1411 | { 1412 | "name": "stdout", 1413 | "output_type": "stream", 1414 | "text": [ 1415 | "2000/2000 [==============================] - 0s 10us/step\n", 1416 | "\n", 1417 | "Testing loss: 0.25, acc: 0.93%\n" 1418 | ] 1419 | } 1420 | ], 1421 | "source": [ 1422 | "loss, acc = model.evaluate(x_test, y_test)\n", 1423 | "print('\\nTesting loss: %.2f, acc: %.2f%%'%(loss, acc))" 1424 | ] 1425 | }, 1426 | { 1427 | "cell_type": "code", 1428 | "execution_count": 44, 1429 | "metadata": {}, 1430 | "outputs": [ 1431 | { 1432 | "name": "stdout", 1433 | "output_type": "stream", 1434 | "text": [ 1435 | "predicted:\n", 1436 | "[5 8 8 ... 6 8 5]\n", 1437 | "True Label:\n", 1438 | "[[0. 0. 0. ... 0. 0. 0.]\n", 1439 | " [0. 0. 0. ... 0. 1. 0.]\n", 1440 | " [0. 0. 0. ... 0. 1. 0.]\n", 1441 | " ...\n", 1442 | " [0. 0. 0. ... 0. 0. 0.]\n", 1443 | " [0. 0. 0. ... 0. 1. 0.]\n", 1444 | " [0. 0. 0. ... 0. 0. 0.]]\n" 1445 | ] 1446 | } 1447 | ], 1448 | "source": [ 1449 | "# The predict_classes function outputs the highest probability class\n", 1450 | "# according to the trained classifier for each input example.\n", 1451 | "predicted_classes = model.predict_classes(x_test)\n", 1452 | "print(\"predicted:\")\n", 1453 | "print(predicted_classes)\n", 1454 | "print(\"True Label:\")\n", 1455 | "print(y_test)" 1456 | ] 1457 | }, 1458 | { 1459 | "cell_type": "code", 1460 | "execution_count": null, 1461 | "metadata": {}, 1462 | "outputs": [], 1463 | "source": [] 1464 | } 1465 | ], 1466 | "metadata": { 1467 | "kernelspec": { 1468 | "display_name": "Python 3", 1469 | "language": "python", 1470 | "name": "python3" 1471 | }, 1472 | "language_info": { 1473 | "codemirror_mode": { 1474 | "name": "ipython", 1475 | "version": 3 1476 | }, 1477 | "file_extension": ".py", 1478 | "mimetype": "text/x-python", 1479 | "name": "python", 1480 | "nbconvert_exporter": "python", 1481 | "pygments_lexer": "ipython3", 1482 | "version": "3.7.9" 1483 | } 1484 | }, 1485 | "nbformat": 4, 1486 | "nbformat_minor": 4 1487 | } 1488 | -------------------------------------------------------------------------------- /image_mod1.py: -------------------------------------------------------------------------------- 1 | """ 2 | 3 | @author: najmeh 4 | """ 5 | 6 | from PIL import Image 7 | import os 8 | 9 | # same path with images 10 | image1 = Image.open('image/dog1.jpeg') 11 | image1.show() 12 | 13 | #%% 14 | # modify 15 | image1.save('dog11.png') # change the image format 16 | 17 | #%% create a "pngs" folder 18 | 19 | for f in os.listdir('.'): # give directory to get the files 20 | if f.endswith('.jpeg'): 21 | i = Image.open(f) 22 | fn, fext = os.path.splitext(f) 23 | i.save('pngs/{}.png'.format(fn)) 24 | 25 | #%% 26 | # resize each image and save it to 300 folder 27 | 28 | size_100 = (100,100) 29 | size_200 = (200,200) 30 | 31 | for f in os.listdir('image'): # give directory to get the files 32 | if f.endswith('.jpeg'): 33 | i = Image.open(f) 34 | fn, fext = os.path.splitext(f) 35 | 36 | i.thumbnail(size_100) # it also keep the aspect ratio 37 | i.save('100/{}_100.p{}'.format(fn, fext)) # rename but keep regular extension 38 | 39 | i.thumbnail(size_200) # it also keep the aspect ratio 40 | i.save('200/{}_200.p{}'.format(fn, fext)) # rename but keep regular extension 41 | 42 | 43 | -------------------------------------------------------------------------------- /img/digit.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Foroozani/ImageProcessing/31b286668e7a0852d976194e1af93f5532963d50/img/digit.png -------------------------------------------------------------------------------- /img/dog1.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Foroozani/ImageProcessing/31b286668e7a0852d976194e1af93f5532963d50/img/dog1.jpeg -------------------------------------------------------------------------------- /img/dog1_100.p.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Foroozani/ImageProcessing/31b286668e7a0852d976194e1af93f5532963d50/img/dog1_100.p.jpeg -------------------------------------------------------------------------------- /img/dog1_200.p.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Foroozani/ImageProcessing/31b286668e7a0852d976194e1af93f5532963d50/img/dog1_200.p.jpeg -------------------------------------------------------------------------------- /img/file: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /img/git.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Foroozani/ImageProcessing/31b286668e7a0852d976194e1af93f5532963d50/img/git.png -------------------------------------------------------------------------------- /mnist.pkl.gz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Foroozani/ImageProcessing/31b286668e7a0852d976194e1af93f5532963d50/mnist.pkl.gz -------------------------------------------------------------------------------- /modules/data_utils.py: -------------------------------------------------------------------------------- 1 | from six.moves import cPickle as pickle 2 | import numpy as np 3 | import os 4 | from scipy.misc import imread 5 | import platform 6 | 7 | def load_pickle(f): 8 | version = platform.python_version_tuple() 9 | if version[0] == '2': 10 | return pickle.load(f) 11 | elif version[0] == '3': 12 | return pickle.load(f, encoding='latin1') 13 | raise ValueError("invalid python version: {}".format(version)) 14 | 15 | def load_CIFAR_batch(filename): 16 | """ load single batch of cifar """ 17 | with open(filename, 'rb') as f: 18 | datadict = load_pickle(f) 19 | X = datadict['data'] 20 | Y = datadict['labels'] 21 | X = X.reshape(10000, 3, 32, 32).transpose(0,2,3,1).astype("float") 22 | Y = np.array(Y) 23 | return X, Y 24 | 25 | def load_CIFAR10(ROOT): 26 | """ load all of cifar """ 27 | xs = [] 28 | ys = [] 29 | for b in range(1,6): 30 | f = os.path.join(ROOT, 'data_batch_%d' % (b, )) 31 | X, Y = load_CIFAR_batch(f) 32 | xs.append(X) 33 | ys.append(Y) 34 | Xtr = np.concatenate(xs) 35 | Ytr = np.concatenate(ys) 36 | del X, Y 37 | Xte, Yte = load_CIFAR_batch(os.path.join(ROOT, 'test_batch')) 38 | return Xtr, Ytr, Xte, Yte 39 | 40 | 41 | def get_CIFAR10_data(cifar10_dir, num_training=49000, num_validation=1000, num_test=1000, 42 | subtract_mean=True): 43 | """ 44 | Load the CIFAR-10 dataset from disk and perform preprocessing to prepare 45 | it for classifiers. These are the same steps as we used for the SVM, but 46 | condensed to a single function. 47 | """ 48 | # Load the raw CIFAR-10 data 49 | X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir) 50 | 51 | # Subsample the data 52 | mask = list(range(num_training, num_training + num_validation)) 53 | X_val = X_train[mask] 54 | y_val = y_train[mask] 55 | mask = list(range(num_training)) 56 | X_train = X_train[mask] 57 | y_train = y_train[mask] 58 | mask = list(range(num_test)) 59 | X_test = X_test[mask] 60 | y_test = y_test[mask] 61 | 62 | # Normalize the data: subtract the mean image 63 | if subtract_mean: 64 | mean_image = np.mean(X_train, axis=0) 65 | X_train -= mean_image 66 | X_val -= mean_image 67 | X_test -= mean_image 68 | 69 | # Transpose so that channels come first 70 | X_train = X_train.transpose(0, 3, 1, 2).copy() 71 | X_val = X_val.transpose(0, 3, 1, 2).copy() 72 | X_test = X_test.transpose(0, 3, 1, 2).copy() 73 | 74 | # Package data into a dictionary 75 | return { 76 | 'X_train': X_train, 'y_train': y_train, 77 | 'X_val': X_val, 'y_val': y_val, 78 | 'X_test': X_test, 'y_test': y_test, 79 | } 80 | -------------------------------------------------------------------------------- /modules/dataset.py: -------------------------------------------------------------------------------- 1 | # for more information read "19-Intro2ML-HodaDataset.ipynb" 2 | import cv2 3 | import numpy as np 4 | from scipy import io 5 | 6 | def load_hoda(training_sample_size=1000, test_sample_size=200, size=5): 7 | #load dataset 8 | trs = training_sample_size 9 | tes = test_sample_size 10 | dataset = io.loadmat('./dataset/Data_hoda_full.mat') 11 | 12 | #test and training set 13 | X_train_orginal = np.squeeze(dataset['Data'][:trs]) 14 | y_train = np.squeeze(dataset['labels'][:trs]) 15 | X_test_original = np.squeeze(dataset['Data'][trs:trs+tes]) 16 | y_test = np.squeeze(dataset['labels'][trs:trs+tes]) 17 | 18 | #resize 19 | X_train_5by5 = [cv2.resize(img, dsize=(size, size)) for img in X_train_orginal] 20 | X_test_5by_5 = [cv2.resize(img, dsize=(size, size)) for img in X_test_original] 21 | #reshape 22 | X_train = [x.reshape(size*size) for x in X_train_5by5] 23 | X_test = [x.reshape(size*size) for x in X_test_5by_5] 24 | 25 | return X_train, y_train, X_test, y_test -------------------------------------------------------------------------------- /modules/file: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /modules/plot_utils.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import seaborn as sns 3 | import matplotlib.pyplot as plt 4 | from sklearn.manifold import TSNE 5 | from sklearn.metrics import confusion_matrix 6 | from utils import softmax 7 | 8 | 9 | def plot_random_samples(X_train, y_train, classes=None, samples_per_class=10, shape=(28, 28), figsize=(5, 4), show_titles=False): 10 | num_classes = len(classes) 11 | 12 | plt.figure(figsize=figsize) 13 | for y, label in enumerate(classes): 14 | idxs = np.flatnonzero(y_train == y) 15 | idxs = np.random.choice(idxs, samples_per_class, replace=False) 16 | for i, idx in enumerate(idxs): 17 | plt_idx = i * num_classes + y + 1 18 | plt.subplot(samples_per_class, num_classes, plt_idx) 19 | plt.imshow(X_train[idx].reshape(shape), cmap=plt.cm.Greys) 20 | plt.axis('off') 21 | if i == 0 and show_titles: 22 | plt.title(label) 23 | plt.show() 24 | 25 | def plot_sample(X, y, idx=None, annot=False, shape=(28, 28)): 26 | if idx is None: 27 | idx = np.random.randint(0, X.shape[0] + 1) 28 | 29 | x = X[idx].reshape(shape) 30 | 31 | figsize = (shape[0] // 2, shape[1] // 2) 32 | plt.figure(figsize=figsize) 33 | sns.heatmap(x, annot=annot, cmap=plt.cm.Greys, cbar=False) 34 | plt.title(y[idx]) 35 | plt.xticks([]) 36 | plt.yticks([]) 37 | plt.show() 38 | 39 | 40 | def plot_tsne(X, y): 41 | plt.figure(figsize=(14, 8)) 42 | X_embedded = TSNE(n_components=2).fit_transform(X) 43 | 44 | cmap = plt.cm.Spectral 45 | for c in range(10): 46 | l = np.flatnonzero(c == y) 47 | plt.scatter(X_embedded[l, 0], X_embedded[l, 1], cmap=cmap, alpha=0.5, label="%d" %c) 48 | 49 | plt.xticks([]) 50 | plt.yticks([]) 51 | plt.legend(loc='best') 52 | plt.show() 53 | 54 | 55 | def predict_and_plot(probs, x, y, mu, classes, shape=(28, 28)): 56 | plt.figure(figsize=(10, 4)) 57 | 58 | # plot the digit 59 | plt.subplot(1, 2, 1) 60 | x = x + mu 61 | plt.imshow(x.reshape(shape), interpolation='nearest', cmap=plt.cm.Greys) 62 | plt.xticks([]) 63 | plt.yticks([]) 64 | plt.title(classes[np.argmax(probs)]) 65 | 66 | # plot top 5 predictions 67 | idx = np.argsort(probs)[5:] 68 | tick_label = [classes[i] for i in idx] 69 | color = ['g' if i == y else 'r' for i in idx] 70 | 71 | plt.subplot(1, 2, 2) 72 | plt.barh(range(5), width=probs[idx], tick_label=tick_label, color=color) 73 | plt.xlim(0, 1) 74 | plt.title("Top 5 predictions") 75 | plt.show() 76 | 77 | 78 | def plot_confusion_matrix(y_true, y_pred, normalize=False, figsize=(12, 12)): 79 | cm = confusion_matrix(y_true, y_pred, labels=range(10)) 80 | plt.figure(figsize=figsize) 81 | annot = cm/cm.sum(axis=1) if normalize else True 82 | sns.heatmap(cm, annot=annot, cmap=plt.cm.Blues, cbar=False) 83 | plt.title("Confusion Matrix") 84 | plt.show() -------------------------------------------------------------------------------- /modules/utils.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | 3 | 4 | def accuracy(y_pred, y_true): 5 | return 100. * np.mean(y_pred == y_true) 6 | 7 | 8 | def softmax(x): 9 | x = x - np.max(x, axis=1, keepdims=True) 10 | exp_x = np.exp(x) 11 | return exp_x / np.sum(exp_x, axis=1, keepdims=True) 12 | 13 | 14 | def softmax_loss(scores, y, mode='train'): 15 | m = scores.shape[0] 16 | probs = softmax(scores) 17 | loss = -np.sum(np.log(probs[range(m), y])) / m 18 | 19 | if mode != 'train': 20 | return loss 21 | 22 | # backward 23 | dscores = probs 24 | dscores[range(m), y] -= 1.0 25 | dscores /= m 26 | 27 | return loss, dscores -------------------------------------------------------------------------------- /read_image.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Image as a data" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Import libraries and list the versions" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 2, 20 | "metadata": {}, 21 | "outputs": [], 22 | "source": [ 23 | "import pandas as pd\n", 24 | "import numpy as np\n", 25 | "import matplotlib.pyplot as plt" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "Check libraries " 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 3, 38 | "metadata": {}, 39 | "outputs": [ 40 | { 41 | "name": "stdout", 42 | "output_type": "stream", 43 | "text": [ 44 | "pandas 1.1.4\n", 45 | "numpy 1.19.2\n" 46 | ] 47 | } 48 | ], 49 | "source": [ 50 | "print('\\n'.join(f'{m.__name__} {m.__version__}' for m in globals().values() if getattr(m, '__version__', None)))" 51 | ] 52 | }, 53 | { 54 | "cell_type": "code", 55 | "execution_count": 4, 56 | "metadata": {}, 57 | "outputs": [ 58 | { 59 | "name": "stdout", 60 | "output_type": "stream", 61 | "text": [ 62 | "Name: numpy\r\n", 63 | "Version: 1.19.2\r\n", 64 | "Summary: NumPy is the fundamental package for array computing with Python.\r\n", 65 | "Home-page: https://www.numpy.org\r\n", 66 | "Author: Travis E. Oliphant et al.\r\n", 67 | "Author-email: None\r\n", 68 | "License: BSD\r\n", 69 | "Location: /home/najmeh/anaconda3/envs/deep-learning/lib/python3.7/site-packages\r\n", 70 | "Requires: \r\n", 71 | "Required-by: tifffile, scipy, scikit-learn, scikit-image, PyWavelets, pandas, mkl-random, mkl-fft, matplotlib, imageio\r\n" 72 | ] 73 | } 74 | ], 75 | "source": [ 76 | "!pip show numpy" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": 5, 82 | "metadata": {}, 83 | "outputs": [ 84 | { 85 | "name": "stdout", 86 | "output_type": "stream", 87 | "text": [ 88 | "Name: matplotlib\r\n", 89 | "Version: 3.3.2\r\n", 90 | "Summary: Python plotting package\r\n", 91 | "Home-page: https://matplotlib.org\r\n", 92 | "Author: John D. Hunter, Michael Droettboom\r\n", 93 | "Author-email: matplotlib-users@python.org\r\n", 94 | "License: PSF\r\n", 95 | "Location: /home/najmeh/anaconda3/envs/deep-learning/lib/python3.7/site-packages\r\n", 96 | "Requires: numpy, cycler, pyparsing, certifi, kiwisolver, pillow, python-dateutil\r\n", 97 | "Required-by: scikit-image\r\n" 98 | ] 99 | } 100 | ], 101 | "source": [ 102 | "!pip show matplotlib" 103 | ] 104 | }, 105 | { 106 | "cell_type": "markdown", 107 | "metadata": {}, 108 | "source": [ 109 | "Load an image from image folder and desplay" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": 6, 115 | "metadata": {}, 116 | "outputs": [ 117 | { 118 | "data": { 119 | "image/png": "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\n", 120 | "text/plain": [ 121 | "
" 122 | ] 123 | }, 124 | "metadata": { 125 | "needs_background": "light" 126 | }, 127 | "output_type": "display_data" 128 | } 129 | ], 130 | "source": [ 131 | "img1 = np.array(plt.imread('./image/git.png'))\n", 132 | "\n", 133 | "# display the image\n", 134 | "plt.imshow(img1)\n", 135 | "plt.show()" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": 7, 141 | "metadata": {}, 142 | "outputs": [ 143 | { 144 | "name": "stdout", 145 | "output_type": "stream", 146 | "text": [ 147 | "Image Dimension is : (159, 177, 4)\n" 148 | ] 149 | } 150 | ], 151 | "source": [ 152 | "print('Image Dimension is :', img1.shape)" 153 | ] 154 | }, 155 | { 156 | "cell_type": "markdown", 157 | "metadata": {}, 158 | "source": [ 159 | "We have read all the four channels of the image. Namely **Red, Green, Blue and Transparency**." 160 | ] 161 | }, 162 | { 163 | "cell_type": "code", 164 | "execution_count": 8, 165 | "metadata": {}, 166 | "outputs": [ 167 | { 168 | "name": "stdout", 169 | "output_type": "stream", 170 | "text": [ 171 | "Given point has three channel RGB = [1. 1. 1. 1.]\n" 172 | ] 173 | } 174 | ], 175 | "source": [ 176 | "print('Given point has three channel RGB =', img1[100,50])" 177 | ] 178 | }, 179 | { 180 | "cell_type": "code", 181 | "execution_count": 9, 182 | "metadata": {}, 183 | "outputs": [ 184 | { 185 | "name": "stdout", 186 | "output_type": "stream", 187 | "text": [ 188 | "Image size is : (425, 640, 3)\n" 189 | ] 190 | } 191 | ], 192 | "source": [ 193 | "print('Image size is :', img2.shape)" 194 | ] 195 | }, 196 | { 197 | "cell_type": "markdown", 198 | "metadata": {}, 199 | "source": [ 200 | "## modify the color image" 201 | ] 202 | }, 203 | { 204 | "cell_type": "code", 205 | "execution_count": 18, 206 | "metadata": {}, 207 | "outputs": [ 208 | { 209 | "data": { 210 | "image/png": "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\n", 211 | "text/plain": [ 212 | "
" 213 | ] 214 | }, 215 | "metadata": { 216 | "needs_background": "light" 217 | }, 218 | "output_type": "display_data" 219 | } 220 | ], 221 | "source": [ 222 | "#channel1=R, chanel2=B, channel3=G\n", 223 | "img1[:,:,1]=0.2 #channel2 changed to 0\n", 224 | "plt.imshow(img1)\n", 225 | "plt.show()" 226 | ] 227 | }, 228 | { 229 | "cell_type": "markdown", 230 | "metadata": {}, 231 | "source": [ 232 | "# cropping " 233 | ] 234 | }, 235 | { 236 | "cell_type": "code", 237 | "execution_count": 21, 238 | "metadata": {}, 239 | "outputs": [ 240 | { 241 | "data": { 242 | "image/png": "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\n", 243 | "text/plain": [ 244 | "
" 245 | ] 246 | }, 247 | "metadata": { 248 | "needs_background": "light" 249 | }, 250 | "output_type": "display_data" 251 | } 252 | ], 253 | "source": [ 254 | "# Load the image\n", 255 | "data = np.array(plt.imread('./image/git.png'))\n", 256 | "\n", 257 | "\n", 258 | "# Set the red channel in this part of the image to 0\n", 259 | "data[50:100, 50:100, 0] = 0\n", 260 | "\n", 261 | "# Set the green channel in this part of the image to 255\n", 262 | "data[50:100, 50:100, 1] = 0\n", 263 | "\n", 264 | "# Set the blue channel in this part of the image to 0\n", 265 | "data[50:100, 50:100, 2] = 0\n", 266 | "\n", 267 | "# Visualize the result\n", 268 | "plt.imshow(data)\n", 269 | "plt.show()" 270 | ] 271 | } 272 | ], 273 | "metadata": { 274 | "kernelspec": { 275 | "display_name": "Python 3", 276 | "language": "python", 277 | "name": "python3" 278 | }, 279 | "language_info": { 280 | "codemirror_mode": { 281 | "name": "ipython", 282 | "version": 3 283 | }, 284 | "file_extension": ".py", 285 | "mimetype": "text/x-python", 286 | "name": "python", 287 | "nbconvert_exporter": "python", 288 | "pygments_lexer": "ipython3", 289 | "version": "3.7.9" 290 | } 291 | }, 292 | "nbformat": 4, 293 | "nbformat_minor": 4 294 | } 295 | --------------------------------------------------------------------------------