diff --git a/.gitignore b/.gitignore index f5e96db..d75edea 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,2 @@ -venv \ No newline at end of file +venv +__pycache__ \ No newline at end of file diff --git a/Lab2/examples/Lab31-mnist.ipynb b/Lab2/examples/Lab31-mnist.ipynb new file mode 100644 index 0000000..46576b2 --- /dev/null +++ b/Lab2/examples/Lab31-mnist.ipynb @@ -0,0 +1,445 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MNIST digits dataset\n", + "\n", + "- First load and view the MNIST digits dataset\n", + "- There are 60000 images in this dataset, but we will only view the first 25 of them:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From f:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\keras\\src\\losses.py:2976: The name tf.losses.sparse_softmax_cross_entropy is deprecated. Please use tf.compat.v1.losses.sparse_softmax_cross_entropy instead.\n", + "\n", + "test_images shape (10000, 28, 28) train_images shape (60000, 28, 28)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Load and visualise the MNIST digits\n", + "import tensorflow as tf\n", + "tf.config.experimental.set_visible_devices([], \"GPU\")\n", + "\n", + "mnist = tf.keras.datasets.mnist\n", + "(train_images0, train_labels0),(test_images0, test_labels0) = mnist.load_data()\n", + "\n", + "print(\"test_images shape\",test_images0.shape,\"train_images shape\",train_images0.shape)\n", + "class_names=[\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\"]\n", + "import matplotlib.pyplot as plt\n", + "# plot first few images\n", + "plt.figure(figsize=(10,10))\n", + "for i in range(25):\n", + " # define subplot\n", + " plt.subplot(5,5,i+1)\n", + " # plot raw pixel data\n", + " plt.imshow(train_images0[i], cmap=plt.get_cmap('gray'))\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + " plt.grid(False)\n", + " # Add a label underneath...\n", + " plt.xlabel(class_names[train_labels0[i]])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Next build a neural-network classifier for these digits.\n", + "\n", + "- We will build a keras model, with the higher-level API concepts" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "outputs": [], + "source": [ + "from tensorflow import keras\n", + "# Each MNIST images are 28*28. Therefore if there are N images, then the\n", + "# shape of the numpy array holding the images is N*28*28\n", + "# We will reshape that here to be N*784, using a numpy reshape.\n", + "# Note that this flattens each image into a single vector length 784.\n", + "#test_images=test_images0.reshape(10000,784) # 10000 test patterns\n", + "#train_images=train_images0.reshape(60000,784) # 60000 train patterns\n", + "\n", + "test_images=test_images0\n", + "train_images=train_images0\n", + "\n", + "# Also rescale greyscale from 8 bit to floating point (by dividing by 255)\n", + "test_images=test_images/255.0\n", + "train_images=train_images/255.0\n", + "\n", + "# Create the model\n", + "\n", + "#model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))\n", + "#model.add(layers.MaxPooling2D((2, 2)))\n", + "#model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n", + "#model.add(layers.MaxPooling2D((2, 2)))\n", + "#model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n", + "\n", + "\n", + "keras_model = tf.keras.models.Sequential([\n", + "tf.keras.layers.Conv2D(28, (3, 3), activation='relu', input_shape=(28, 28, 1)),\n", + "tf.keras.layers.Dropout(.2, input_shape=(2,)),\n", + "tf.keras.layers.MaxPooling2D((2, 2)),\n", + "tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n", + "tf.keras.layers.Dropout(.2, input_shape=(2,)),\n", + "tf.keras.layers.MaxPooling2D((2, 2)),\n", + "tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n", + "tf.keras.layers.Dropout(.2, input_shape=(2,)),\n", + "tf.keras.layers.Flatten(),\n", + "tf.keras.layers.Dense(64, activation='relu'),\n", + "tf.keras.layers.Dense(10, activation='softmax')\n", + "])\n", + "\n", + "keras_model.build(input_shape=[None,784])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## View the keras model summary information\n", + "\n", + "- This shows you how many layers your neural network has, and how many weights, etc." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_2\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " conv2d_6 (Conv2D) (None, 26, 26, 28) 280 \n", + " \n", + " dropout (Dropout) (None, 26, 26, 28) 0 \n", + " \n", + " max_pooling2d_4 (MaxPooling (None, 13, 13, 28) 0 \n", + " 2D) \n", + " \n", + " conv2d_7 (Conv2D) (None, 11, 11, 64) 16192 \n", + " \n", + " dropout_1 (Dropout) (None, 11, 11, 64) 0 \n", + " \n", + " max_pooling2d_5 (MaxPooling (None, 5, 5, 64) 0 \n", + " 2D) \n", + " \n", + " conv2d_8 (Conv2D) (None, 3, 3, 64) 36928 \n", + " \n", + " dropout_2 (Dropout) (None, 3, 3, 64) 0 \n", + " \n", + " flatten_2 (Flatten) (None, 576) 0 \n", + " \n", + " dense_4 (Dense) (None, 64) 36928 \n", + " \n", + " dense_5 (Dense) (None, 10) 650 \n", + " \n", + "=================================================================\n", + "Total params: 90,978\n", + "Trainable params: 90,978\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "# View the model summary information...\n", + "keras_model.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train the Keras model\n", + "\n", + "- We will use SGD optimiser (ordinary gradient descent)\n", + "- We will use Cross Entropy loss (\"SparseCategoricalCrossentropy\")\n", + "- We will run 200 training iterations (epochs)..." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/20\n", + "WARNING:tensorflow:From f:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\keras\\src\\utils\\tf_utils.py:492: The name tf.ragged.RaggedTensorValue is deprecated. Please use tf.compat.v1.ragged.RaggedTensorValue instead.\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "f:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\keras\\src\\backend.py:5727: UserWarning: \"`sparse_categorical_crossentropy` received `from_logits=True`, but the `output` argument was produced by a Softmax activation and thus does not represent logits. Was this intended?\n", + " output, from_logits = _get_logits(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "600/600 [==============================] - 14s 21ms/step - loss: 0.2375 - sparse_categorical_accuracy: 0.9275 - val_loss: 0.0672 - val_sparse_categorical_accuracy: 0.9833\n", + "Epoch 2/20\n", + "600/600 [==============================] - 13s 22ms/step - loss: 0.0696 - sparse_categorical_accuracy: 0.9789 - val_loss: 0.0431 - val_sparse_categorical_accuracy: 0.9901\n", + "Epoch 3/20\n", + "600/600 [==============================] - 13s 22ms/step - loss: 0.0521 - sparse_categorical_accuracy: 0.9839 - val_loss: 0.0403 - val_sparse_categorical_accuracy: 0.9903\n", + "Epoch 4/20\n", + "600/600 [==============================] - 13s 22ms/step - loss: 0.0408 - sparse_categorical_accuracy: 0.9874 - val_loss: 0.0274 - val_sparse_categorical_accuracy: 0.9927\n", + "Epoch 5/20\n", + "600/600 [==============================] - 13s 22ms/step - loss: 0.0356 - sparse_categorical_accuracy: 0.9887 - val_loss: 0.0294 - val_sparse_categorical_accuracy: 0.9921\n", + "Epoch 6/20\n", + "600/600 [==============================] - 13s 22ms/step - loss: 0.0309 - sparse_categorical_accuracy: 0.9901 - val_loss: 0.0280 - val_sparse_categorical_accuracy: 0.9911\n", + "Epoch 7/20\n", + "600/600 [==============================] - 13s 22ms/step - loss: 0.0288 - sparse_categorical_accuracy: 0.9909 - val_loss: 0.0222 - val_sparse_categorical_accuracy: 0.9942\n", + "Epoch 8/20\n", + "600/600 [==============================] - 14s 23ms/step - loss: 0.0261 - sparse_categorical_accuracy: 0.9913 - val_loss: 0.0225 - val_sparse_categorical_accuracy: 0.9937\n", + "Epoch 9/20\n", + "600/600 [==============================] - 15s 24ms/step - loss: 0.0220 - sparse_categorical_accuracy: 0.9929 - val_loss: 0.0260 - val_sparse_categorical_accuracy: 0.9927\n", + "Epoch 10/20\n", + "600/600 [==============================] - 15s 24ms/step - loss: 0.0207 - sparse_categorical_accuracy: 0.9934 - val_loss: 0.0217 - val_sparse_categorical_accuracy: 0.9940\n", + "Epoch 11/20\n", + "600/600 [==============================] - 14s 24ms/step - loss: 0.0198 - sparse_categorical_accuracy: 0.9934 - val_loss: 0.0225 - val_sparse_categorical_accuracy: 0.9926\n", + "Epoch 12/20\n", + "600/600 [==============================] - 15s 25ms/step - loss: 0.0169 - sparse_categorical_accuracy: 0.9945 - val_loss: 0.0214 - val_sparse_categorical_accuracy: 0.9930\n", + "Epoch 13/20\n", + "600/600 [==============================] - 14s 23ms/step - loss: 0.0169 - sparse_categorical_accuracy: 0.9943 - val_loss: 0.0235 - val_sparse_categorical_accuracy: 0.9929\n", + "Epoch 14/20\n", + "600/600 [==============================] - 14s 24ms/step - loss: 0.0149 - sparse_categorical_accuracy: 0.9949 - val_loss: 0.0235 - val_sparse_categorical_accuracy: 0.9933\n", + "Epoch 15/20\n", + "600/600 [==============================] - 15s 25ms/step - loss: 0.0145 - sparse_categorical_accuracy: 0.9954 - val_loss: 0.0205 - val_sparse_categorical_accuracy: 0.9939\n", + "Epoch 16/20\n", + "600/600 [==============================] - 15s 24ms/step - loss: 0.0143 - sparse_categorical_accuracy: 0.9954 - val_loss: 0.0217 - val_sparse_categorical_accuracy: 0.9934\n", + "Epoch 17/20\n", + "600/600 [==============================] - 14s 23ms/step - loss: 0.0128 - sparse_categorical_accuracy: 0.9956 - val_loss: 0.0222 - val_sparse_categorical_accuracy: 0.9938\n", + "Epoch 18/20\n", + "600/600 [==============================] - 13s 21ms/step - loss: 0.0132 - sparse_categorical_accuracy: 0.9955 - val_loss: 0.0225 - val_sparse_categorical_accuracy: 0.9939\n", + "Epoch 19/20\n", + "600/600 [==============================] - 13s 22ms/step - loss: 0.0106 - sparse_categorical_accuracy: 0.9966 - val_loss: 0.0224 - val_sparse_categorical_accuracy: 0.9933\n", + "Epoch 20/20\n", + "600/600 [==============================] - 13s 22ms/step - loss: 0.0118 - sparse_categorical_accuracy: 0.9961 - val_loss: 0.0214 - val_sparse_categorical_accuracy: 0.9939\n" + ] + } + ], + "source": [ + "keras_model.compile(\n", + " optimizer=tf.keras.optimizers.Adam(0.001),\n", + " loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n", + " metrics=[tf.keras.metrics.SparseCategoricalAccuracy()],\n", + ")\n", + "\n", + "# Train loop\n", + "history = keras_model.fit(\n", + " train_images,\n", + " train_labels0,\n", + " batch_size=100,\n", + " epochs=20,\n", + " validation_data=(test_images, test_labels0),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## View the training performance\n", + "\n", + "- When the Keras fit loop runs, it returns a \"history\" object, which includes a dictionary of the trianing history.\n", + "\n", + "- Hence we can plot graphs of the training performance (Accuracy, Loss), for both the \"Training\" and \"Validation\" sets...." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Key: loss\n", + "Key: sparse_categorical_accuracy\n", + "Key: val_loss\n", + "Key: val_sparse_categorical_accuracy\n" + ] + } + ], + "source": [ + "# first show keys for data series recorded by fit loop:\n", + "for item in history.history:\n", + " print(\"Key:\",item)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "plt.plot(history.history['loss'],label=\"train\")\n", + "plt.plot(history.history['val_loss'],label=\"validation\")\n", + "plt.title('Model Loss')\n", + "plt.yscale('log')\n", + "plt.ylabel('Cross Entropy')\n", + "plt.xlabel('Iteration')\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "#print(\"history\",history.history)\n", + "plt.plot(history.history['sparse_categorical_accuracy'],label=\"train\")\n", + "plt.plot(history.history['val_sparse_categorical_accuracy'],label=\"validation\")\n", + "plt.title('Model Accuracy')\n", + "#plt.yscale('log')\n", + "plt.ylabel('Acc')\n", + "plt.xlabel('Iteration')\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Inspect how well the system is working on a sample of 25 new images (from the test set)...\n", + "- The test set has a lot of images in it, but we can only view 25 at a time.\n", + "- Hence rerun this code block several times, to get a different random set of samples from the test set" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "plt.figure(figsize=(10,10))\n", + "# plot 25 random images from the test set.\n", + "first_index=np.random.randint(len(test_images)-25)\n", + "for i in range(first_index,first_index+25):\n", + " # define subplot\n", + " plt.subplot(5,5,i+1-first_index)\n", + " # plot raw pixel data\n", + " plt.imshow(test_images0[i], cmap=plt.get_cmap('gray'))\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + " plt.grid(False)\n", + " if class_names!=None:\n", + " prediction=keras_model(test_images[i:i+1])[0,:] # This will be a vector of length 10\n", + " prediction_class=np.argmax(prediction) # Pick the index of the largest element of the length-10 vector\n", + " # Add a label underneath...\n", + " true_label=test_labels0[i]\n", + " class_name=class_names[prediction_class]\n", + " plt.xlabel(class_name+\" \"+(\"CORRECT\" if prediction_class==true_label else \"WRONG\"))\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Lab2/main.ipynb b/Lab2/main.ipynb index c6e0893..09f8a2d 100644 --- a/Lab2/main.ipynb +++ b/Lab2/main.ipynb @@ -1,15 +1,8 @@ { "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Lab24" - ] - }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +11,15 @@ "import pandas as pd\n", "import imageio.v3 as imageio\n", "import numpy as np\n", - "from tensorflow import keras" + "from tensorflow import keras\n", + "import tensorflow.keras.layers as layers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Lab24" ] }, { @@ -467,7 +468,7 @@ "train_images = train_images/255.0\n", "\n", "keras_model = tf.keras.models.Sequential([\n", - " tf.keras.layers.Dense(20, activation='relu'),\n", + " tf.keras.layers.Dense(20, activation='relu'),\n", " tf.keras.layers.Dense(10, activation='softmax')\n", "])\n", "\n", @@ -476,18 +477,18 @@ "keras_model.summary()\n", "\n", "keras_model.compile(\n", - " optimizer=tf.keras.optimizers.SGD(0.2),\n", - " loss=tf.keras.losses.CategoricalHinge(),\n", - " metrics=[tf.keras.metrics.SparseCategoricalAccuracy()],\n", + " optimizer=tf.keras.optimizers.SGD(0.2),\n", + " loss=tf.keras.losses.CategoricalHinge(),\n", + " metrics=[tf.keras.metrics.SparseCategoricalAccuracy()],\n", ")\n", "\n", "# Train loop\n", "history = keras_model.fit(\n", - " train_images,\n", - " train_labels0,\n", - " batch_size=len(train_images),\n", - " epochs=200,\n", - " validation_data=(test_images, test_labels0),\n", + " train_images,\n", + " train_labels0,\n", + " batch_size=len(train_images),\n", + " epochs=200,\n", + " validation_data=(test_images, test_labels0),\n", ")\n", "\n" ] @@ -1407,6 +1408,1068 @@ "plt.legend()\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Lab31" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2.\n", + "\n", + "Adaptuokite Lab24 MNIST kodą pridedant konvoliucinius sluoksnius (MaxPooling2D, Conv2D, Flatten)." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_17\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " conv2d_24 (Conv2D) (None, 27, 27, 8) 40 \n", + " \n", + " max_pooling2d_21 (MaxPooli (None, 13, 13, 8) 0 \n", + " ng2D) \n", + " \n", + " conv2d_25 (Conv2D) (None, 12, 12, 16) 528 \n", + " \n", + " max_pooling2d_22 (MaxPooli (None, 6, 6, 16) 0 \n", + " ng2D) \n", + " \n", + " flatten_16 (Flatten) (None, 576) 0 \n", + " \n", + " dense_31 (Dense) (None, 10) 5770 \n", + " \n", + "=================================================================\n", + "Total params: 6338 (24.76 KB)\n", + "Trainable params: 6338 (24.76 KB)\n", + "Non-trainable params: 0 (0.00 Byte)\n", + "_________________________________________________________________\n", + "Epoch 1/200\n", + "1/1 [==============================] - 11s 11s/step - loss: 2.3231 - sparse_categorical_accuracy: 0.0935 - val_loss: 2.3027 - val_sparse_categorical_accuracy: 0.1181\n", + "Epoch 2/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 2.3031 - sparse_categorical_accuracy: 0.1187 - val_loss: 2.2867 - val_sparse_categorical_accuracy: 0.1464\n", + "Epoch 3/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 2.2872 - sparse_categorical_accuracy: 0.1497 - val_loss: 2.2725 - val_sparse_categorical_accuracy: 0.1778\n", + "Epoch 4/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 2.2730 - sparse_categorical_accuracy: 0.1830 - val_loss: 2.2586 - val_sparse_categorical_accuracy: 0.2101\n", + "Epoch 5/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 2.2593 - sparse_categorical_accuracy: 0.2157 - val_loss: 2.2436 - val_sparse_categorical_accuracy: 0.2497\n", + "Epoch 6/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 2.2444 - sparse_categorical_accuracy: 0.2482 - val_loss: 2.2265 - val_sparse_categorical_accuracy: 0.2922\n", + "Epoch 7/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 2.2275 - sparse_categorical_accuracy: 0.2905 - val_loss: 2.2064 - val_sparse_categorical_accuracy: 0.3411\n", + "Epoch 8/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 2.2076 - sparse_categorical_accuracy: 0.3380 - val_loss: 2.1813 - val_sparse_categorical_accuracy: 0.3924\n", + "Epoch 9/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 2.1829 - sparse_categorical_accuracy: 0.3882 - val_loss: 2.1496 - val_sparse_categorical_accuracy: 0.4492\n", + "Epoch 10/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 2.1515 - sparse_categorical_accuracy: 0.4465 - val_loss: 2.1091 - val_sparse_categorical_accuracy: 0.5022\n", + "Epoch 11/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 2.1115 - sparse_categorical_accuracy: 0.4981 - val_loss: 2.0564 - val_sparse_categorical_accuracy: 0.5529\n", + "Epoch 12/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 2.0595 - sparse_categorical_accuracy: 0.5463 - val_loss: 1.9875 - val_sparse_categorical_accuracy: 0.5811\n", + "Epoch 13/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.9916 - sparse_categorical_accuracy: 0.5745 - val_loss: 1.8943 - val_sparse_categorical_accuracy: 0.6322\n", + "Epoch 14/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.8999 - sparse_categorical_accuracy: 0.6226 - val_loss: 1.7726 - val_sparse_categorical_accuracy: 0.6620\n", + "Epoch 15/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.7801 - sparse_categorical_accuracy: 0.6516 - val_loss: 1.6186 - val_sparse_categorical_accuracy: 0.6927\n", + "Epoch 16/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.6289 - sparse_categorical_accuracy: 0.6790 - val_loss: 1.4365 - val_sparse_categorical_accuracy: 0.7234\n", + "Epoch 17/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.4507 - sparse_categorical_accuracy: 0.7081 - val_loss: 1.2450 - val_sparse_categorical_accuracy: 0.7447\n", + "Epoch 18/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.2634 - sparse_categorical_accuracy: 0.7287 - val_loss: 1.0771 - val_sparse_categorical_accuracy: 0.7580\n", + "Epoch 19/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.1001 - sparse_categorical_accuracy: 0.7435 - val_loss: 1.0968 - val_sparse_categorical_accuracy: 0.6258\n", + "Epoch 20/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.1150 - sparse_categorical_accuracy: 0.6191 - val_loss: 2.8059 - val_sparse_categorical_accuracy: 0.4252\n", + "Epoch 21/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 2.8337 - sparse_categorical_accuracy: 0.4113 - val_loss: 2.7845 - val_sparse_categorical_accuracy: 0.4922\n", + "Epoch 22/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 2.7802 - sparse_categorical_accuracy: 0.4894 - val_loss: 1.9623 - val_sparse_categorical_accuracy: 0.4897\n", + "Epoch 23/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.9748 - sparse_categorical_accuracy: 0.4824 - val_loss: 1.8047 - val_sparse_categorical_accuracy: 0.6128\n", + "Epoch 24/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.8204 - sparse_categorical_accuracy: 0.6014 - val_loss: 1.6263 - val_sparse_categorical_accuracy: 0.6479\n", + "Epoch 25/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.6444 - sparse_categorical_accuracy: 0.6369 - val_loss: 1.3955 - val_sparse_categorical_accuracy: 0.6670\n", + "Epoch 26/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.4163 - sparse_categorical_accuracy: 0.6573 - val_loss: 1.1135 - val_sparse_categorical_accuracy: 0.7711\n", + "Epoch 27/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.1382 - sparse_categorical_accuracy: 0.7553 - val_loss: 0.8681 - val_sparse_categorical_accuracy: 0.8239\n", + "Epoch 28/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.8970 - sparse_categorical_accuracy: 0.8044 - val_loss: 0.7336 - val_sparse_categorical_accuracy: 0.8258\n", + "Epoch 29/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.7629 - sparse_categorical_accuracy: 0.8118 - val_loss: 0.6685 - val_sparse_categorical_accuracy: 0.8254\n", + "Epoch 30/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.7002 - sparse_categorical_accuracy: 0.8078 - val_loss: 0.7937 - val_sparse_categorical_accuracy: 0.7718\n", + "Epoch 31/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.8176 - sparse_categorical_accuracy: 0.7602 - val_loss: 1.4872 - val_sparse_categorical_accuracy: 0.4954\n", + "Epoch 32/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.5201 - sparse_categorical_accuracy: 0.4868 - val_loss: 2.7679 - val_sparse_categorical_accuracy: 0.6833\n", + "Epoch 33/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 2.7496 - sparse_categorical_accuracy: 0.6783 - val_loss: 1.7345 - val_sparse_categorical_accuracy: 0.6377\n", + "Epoch 34/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.7398 - sparse_categorical_accuracy: 0.6330 - val_loss: 1.5192 - val_sparse_categorical_accuracy: 0.7493\n", + "Epoch 35/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.5273 - sparse_categorical_accuracy: 0.7374 - val_loss: 1.3959 - val_sparse_categorical_accuracy: 0.7688\n", + "Epoch 36/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.4055 - sparse_categorical_accuracy: 0.7601 - val_loss: 1.2664 - val_sparse_categorical_accuracy: 0.7812\n", + "Epoch 37/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.2776 - sparse_categorical_accuracy: 0.7734 - val_loss: 1.1224 - val_sparse_categorical_accuracy: 0.7852\n", + "Epoch 38/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.1353 - sparse_categorical_accuracy: 0.7782 - val_loss: 0.9562 - val_sparse_categorical_accuracy: 0.7860\n", + "Epoch 39/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.9709 - sparse_categorical_accuracy: 0.7802 - val_loss: 0.7709 - val_sparse_categorical_accuracy: 0.8039\n", + "Epoch 40/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.7881 - sparse_categorical_accuracy: 0.7975 - val_loss: 0.6252 - val_sparse_categorical_accuracy: 0.8466\n", + "Epoch 41/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.6471 - sparse_categorical_accuracy: 0.8396 - val_loss: 0.5564 - val_sparse_categorical_accuracy: 0.8529\n", + "Epoch 42/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.5797 - sparse_categorical_accuracy: 0.8446 - val_loss: 0.5172 - val_sparse_categorical_accuracy: 0.8564\n", + "Epoch 43/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.5409 - sparse_categorical_accuracy: 0.8483 - val_loss: 0.4909 - val_sparse_categorical_accuracy: 0.8621\n", + "Epoch 44/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.5147 - sparse_categorical_accuracy: 0.8522 - val_loss: 0.4721 - val_sparse_categorical_accuracy: 0.8651\n", + "Epoch 45/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.4960 - sparse_categorical_accuracy: 0.8548 - val_loss: 0.4612 - val_sparse_categorical_accuracy: 0.8674\n", + "Epoch 46/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.4848 - sparse_categorical_accuracy: 0.8554 - val_loss: 0.4766 - val_sparse_categorical_accuracy: 0.8586\n", + "Epoch 47/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.5004 - sparse_categorical_accuracy: 0.8462 - val_loss: 0.6405 - val_sparse_categorical_accuracy: 0.7917\n", + "Epoch 48/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.6626 - sparse_categorical_accuracy: 0.7847 - val_loss: 1.2383 - val_sparse_categorical_accuracy: 0.6740\n", + "Epoch 49/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.2615 - sparse_categorical_accuracy: 0.6662 - val_loss: 1.5462 - val_sparse_categorical_accuracy: 0.7564\n", + "Epoch 50/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 1.5575 - sparse_categorical_accuracy: 0.7496 - val_loss: 0.9303 - val_sparse_categorical_accuracy: 0.7687\n", + "Epoch 51/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.9450 - sparse_categorical_accuracy: 0.7586 - val_loss: 0.6835 - val_sparse_categorical_accuracy: 0.8314\n", + "Epoch 52/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.7040 - sparse_categorical_accuracy: 0.8248 - val_loss: 0.5411 - val_sparse_categorical_accuracy: 0.8726\n", + "Epoch 53/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.5638 - sparse_categorical_accuracy: 0.8659 - val_loss: 0.4692 - val_sparse_categorical_accuracy: 0.8820\n", + "Epoch 54/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.4922 - sparse_categorical_accuracy: 0.8741 - val_loss: 0.4347 - val_sparse_categorical_accuracy: 0.8861\n", + "Epoch 55/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.4576 - sparse_categorical_accuracy: 0.8764 - val_loss: 0.4143 - val_sparse_categorical_accuracy: 0.8863\n", + "Epoch 56/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.4368 - sparse_categorical_accuracy: 0.8777 - val_loss: 0.4003 - val_sparse_categorical_accuracy: 0.8881\n", + "Epoch 57/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.4225 - sparse_categorical_accuracy: 0.8794 - val_loss: 0.3901 - val_sparse_categorical_accuracy: 0.8890\n", + "Epoch 58/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.4118 - sparse_categorical_accuracy: 0.8803 - val_loss: 0.3817 - val_sparse_categorical_accuracy: 0.8908\n", + "Epoch 59/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.4032 - sparse_categorical_accuracy: 0.8826 - val_loss: 0.3750 - val_sparse_categorical_accuracy: 0.8920\n", + "Epoch 60/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.3961 - sparse_categorical_accuracy: 0.8833 - val_loss: 0.3688 - val_sparse_categorical_accuracy: 0.8945\n", + "Epoch 61/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.3898 - sparse_categorical_accuracy: 0.8855 - val_loss: 0.3639 - val_sparse_categorical_accuracy: 0.8938\n", + "Epoch 62/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.3843 - sparse_categorical_accuracy: 0.8856 - val_loss: 0.3587 - val_sparse_categorical_accuracy: 0.8980\n", + "Epoch 63/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.3795 - sparse_categorical_accuracy: 0.8884 - val_loss: 0.3561 - val_sparse_categorical_accuracy: 0.8954\n", + "Epoch 64/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.3756 - sparse_categorical_accuracy: 0.8873 - val_loss: 0.3526 - val_sparse_categorical_accuracy: 0.8997\n", + "Epoch 65/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.3734 - sparse_categorical_accuracy: 0.8906 - val_loss: 0.3581 - val_sparse_categorical_accuracy: 0.8915\n", + "Epoch 66/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.3762 - sparse_categorical_accuracy: 0.8835 - val_loss: 0.3687 - val_sparse_categorical_accuracy: 0.8902\n", + "Epoch 67/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.3904 - sparse_categorical_accuracy: 0.8829 - val_loss: 0.4312 - val_sparse_categorical_accuracy: 0.8587\n", + "Epoch 68/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.4470 - sparse_categorical_accuracy: 0.8498 - val_loss: 0.5534 - val_sparse_categorical_accuracy: 0.8044\n", + "Epoch 69/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.5745 - sparse_categorical_accuracy: 0.7966 - val_loss: 0.8486 - val_sparse_categorical_accuracy: 0.7387\n", + "Epoch 70/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.8618 - sparse_categorical_accuracy: 0.7351 - val_loss: 0.8455 - val_sparse_categorical_accuracy: 0.7509\n", + "Epoch 71/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.8635 - sparse_categorical_accuracy: 0.7474 - val_loss: 0.4267 - val_sparse_categorical_accuracy: 0.8745\n", + "Epoch 72/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.4436 - sparse_categorical_accuracy: 0.8658 - val_loss: 0.3634 - val_sparse_categorical_accuracy: 0.9055\n", + "Epoch 73/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.3854 - sparse_categorical_accuracy: 0.8975 - val_loss: 0.3447 - val_sparse_categorical_accuracy: 0.9050\n", + "Epoch 74/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.3646 - sparse_categorical_accuracy: 0.8969 - val_loss: 0.3333 - val_sparse_categorical_accuracy: 0.9103\n", + "Epoch 75/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.3538 - sparse_categorical_accuracy: 0.9018 - val_loss: 0.3265 - val_sparse_categorical_accuracy: 0.9082\n", + "Epoch 76/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.3461 - sparse_categorical_accuracy: 0.9004 - val_loss: 0.3205 - val_sparse_categorical_accuracy: 0.9120\n", + "Epoch 77/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.3402 - sparse_categorical_accuracy: 0.9031 - val_loss: 0.3161 - val_sparse_categorical_accuracy: 0.9118\n", + "Epoch 78/200\n", + "1/1 [==============================] - 2s 2s/step - loss: 0.3353 - sparse_categorical_accuracy: 0.9025 - val_loss: 0.3119 - val_sparse_categorical_accuracy: 0.9129\n", + "Epoch 79/200\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[27], line 32\u001b[0m\n\u001b[0;32m 25\u001b[0m keras_model\u001b[38;5;241m.\u001b[39mcompile(\n\u001b[0;32m 26\u001b[0m optimizer\u001b[38;5;241m=\u001b[39mtf\u001b[38;5;241m.\u001b[39mkeras\u001b[38;5;241m.\u001b[39moptimizers\u001b[38;5;241m.\u001b[39mSGD(\u001b[38;5;241m0.2\u001b[39m),\n\u001b[0;32m 27\u001b[0m loss\u001b[38;5;241m=\u001b[39mtf\u001b[38;5;241m.\u001b[39mkeras\u001b[38;5;241m.\u001b[39mlosses\u001b[38;5;241m.\u001b[39mSparseCategoricalCrossentropy(),\n\u001b[0;32m 28\u001b[0m metrics\u001b[38;5;241m=\u001b[39m[tf\u001b[38;5;241m.\u001b[39mkeras\u001b[38;5;241m.\u001b[39mmetrics\u001b[38;5;241m.\u001b[39mSparseCategoricalAccuracy()],\n\u001b[0;32m 29\u001b[0m )\n\u001b[0;32m 31\u001b[0m \u001b[38;5;66;03m# Train loop\u001b[39;00m\n\u001b[1;32m---> 32\u001b[0m history \u001b[38;5;241m=\u001b[39m \u001b[43mkeras_model\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 33\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrain_images\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 34\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrain_labels0\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 35\u001b[0m \u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtrain_images\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 36\u001b[0m \u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m200\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 37\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtest_images\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest_labels0\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 38\u001b[0m \u001b[43m)\u001b[49m\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\keras\\src\\utils\\traceback_utils.py:65\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 63\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m 64\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m---> 65\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 66\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m 67\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\keras\\src\\engine\\training.py:1807\u001b[0m, in \u001b[0;36mModel.fit\u001b[1;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[0;32m 1799\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m tf\u001b[38;5;241m.\u001b[39mprofiler\u001b[38;5;241m.\u001b[39mexperimental\u001b[38;5;241m.\u001b[39mTrace(\n\u001b[0;32m 1800\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtrain\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m 1801\u001b[0m epoch_num\u001b[38;5;241m=\u001b[39mepoch,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1804\u001b[0m _r\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m,\n\u001b[0;32m 1805\u001b[0m ):\n\u001b[0;32m 1806\u001b[0m callbacks\u001b[38;5;241m.\u001b[39mon_train_batch_begin(step)\n\u001b[1;32m-> 1807\u001b[0m tmp_logs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrain_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43miterator\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1808\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m data_handler\u001b[38;5;241m.\u001b[39mshould_sync:\n\u001b[0;32m 1809\u001b[0m context\u001b[38;5;241m.\u001b[39masync_wait()\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\util\\traceback_utils.py:150\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 148\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m 149\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 150\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 151\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m 152\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\polymorphic_function.py:832\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m 829\u001b[0m compiler \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mxla\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnonXla\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 831\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m OptionalXlaContext(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile):\n\u001b[1;32m--> 832\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 834\u001b[0m new_tracing_count \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexperimental_get_tracing_count()\n\u001b[0;32m 835\u001b[0m without_tracing \u001b[38;5;241m=\u001b[39m (tracing_count \u001b[38;5;241m==\u001b[39m new_tracing_count)\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\polymorphic_function.py:868\u001b[0m, in \u001b[0;36mFunction._call\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m 865\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n\u001b[0;32m 866\u001b[0m \u001b[38;5;66;03m# In this case we have created variables on the first call, so we run the\u001b[39;00m\n\u001b[0;32m 867\u001b[0m \u001b[38;5;66;03m# defunned version which is guaranteed to never create variables.\u001b[39;00m\n\u001b[1;32m--> 868\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtracing_compilation\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 869\u001b[0m \u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_no_variable_creation_config\u001b[49m\n\u001b[0;32m 870\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 871\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_variable_creation_config \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 872\u001b[0m \u001b[38;5;66;03m# Release the lock early so that multiple threads can perform the call\u001b[39;00m\n\u001b[0;32m 873\u001b[0m \u001b[38;5;66;03m# in parallel.\u001b[39;00m\n\u001b[0;32m 874\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\tracing_compilation.py:139\u001b[0m, in \u001b[0;36mcall_function\u001b[1;34m(args, kwargs, tracing_options)\u001b[0m\n\u001b[0;32m 137\u001b[0m bound_args \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mbind(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m 138\u001b[0m flat_inputs \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39munpack_inputs(bound_args)\n\u001b[1;32m--> 139\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# pylint: disable=protected-access\u001b[39;49;00m\n\u001b[0;32m 140\u001b[0m \u001b[43m \u001b[49m\u001b[43mflat_inputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcaptured_inputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcaptured_inputs\u001b[49m\n\u001b[0;32m 141\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\concrete_function.py:1323\u001b[0m, in \u001b[0;36mConcreteFunction._call_flat\u001b[1;34m(self, tensor_inputs, captured_inputs)\u001b[0m\n\u001b[0;32m 1319\u001b[0m possible_gradient_type \u001b[38;5;241m=\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPossibleTapeGradientTypes(args)\n\u001b[0;32m 1320\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (possible_gradient_type \u001b[38;5;241m==\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPOSSIBLE_GRADIENT_TYPES_NONE\n\u001b[0;32m 1321\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m executing_eagerly):\n\u001b[0;32m 1322\u001b[0m \u001b[38;5;66;03m# No tape is watching; skip to running the function.\u001b[39;00m\n\u001b[1;32m-> 1323\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_inference_function\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_preflattened\u001b[49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1324\u001b[0m forward_backward \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_select_forward_and_backward_functions(\n\u001b[0;32m 1325\u001b[0m args,\n\u001b[0;32m 1326\u001b[0m possible_gradient_type,\n\u001b[0;32m 1327\u001b[0m executing_eagerly)\n\u001b[0;32m 1328\u001b[0m forward_function, args_with_tangents \u001b[38;5;241m=\u001b[39m forward_backward\u001b[38;5;241m.\u001b[39mforward()\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\atomic_function.py:216\u001b[0m, in \u001b[0;36mAtomicFunction.call_preflattened\u001b[1;34m(self, args)\u001b[0m\n\u001b[0;32m 214\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcall_preflattened\u001b[39m(\u001b[38;5;28mself\u001b[39m, args: Sequence[core\u001b[38;5;241m.\u001b[39mTensor]) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[0;32m 215\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Calls with flattened tensor inputs and returns the structured output.\"\"\"\u001b[39;00m\n\u001b[1;32m--> 216\u001b[0m flat_outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 217\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mpack_output(flat_outputs)\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\atomic_function.py:251\u001b[0m, in \u001b[0;36mAtomicFunction.call_flat\u001b[1;34m(self, *args)\u001b[0m\n\u001b[0;32m 249\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m record\u001b[38;5;241m.\u001b[39mstop_recording():\n\u001b[0;32m 250\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mexecuting_eagerly():\n\u001b[1;32m--> 251\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_bound_context\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 252\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 253\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 254\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunction_type\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mflat_outputs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 255\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 256\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 257\u001b[0m outputs \u001b[38;5;241m=\u001b[39m make_call_op_in_graph(\n\u001b[0;32m 258\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 259\u001b[0m \u001b[38;5;28mlist\u001b[39m(args),\n\u001b[0;32m 260\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mfunction_call_options\u001b[38;5;241m.\u001b[39mas_attrs(),\n\u001b[0;32m 261\u001b[0m )\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\context.py:1486\u001b[0m, in \u001b[0;36mContext.call_function\u001b[1;34m(self, name, tensor_inputs, num_outputs)\u001b[0m\n\u001b[0;32m 1484\u001b[0m cancellation_context \u001b[38;5;241m=\u001b[39m cancellation\u001b[38;5;241m.\u001b[39mcontext()\n\u001b[0;32m 1485\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cancellation_context \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m-> 1486\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mexecute\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 1487\u001b[0m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecode\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mutf-8\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1488\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_outputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1489\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtensor_inputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1490\u001b[0m \u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1491\u001b[0m \u001b[43m \u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1492\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1493\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 1494\u001b[0m outputs \u001b[38;5;241m=\u001b[39m execute\u001b[38;5;241m.\u001b[39mexecute_with_cancellation(\n\u001b[0;32m 1495\u001b[0m name\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mutf-8\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[0;32m 1496\u001b[0m num_outputs\u001b[38;5;241m=\u001b[39mnum_outputs,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1500\u001b[0m cancellation_manager\u001b[38;5;241m=\u001b[39mcancellation_context,\n\u001b[0;32m 1501\u001b[0m )\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\execute.py:53\u001b[0m, in \u001b[0;36mquick_execute\u001b[1;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[0;32m 51\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m 52\u001b[0m ctx\u001b[38;5;241m.\u001b[39mensure_initialized()\n\u001b[1;32m---> 53\u001b[0m tensors \u001b[38;5;241m=\u001b[39m \u001b[43mpywrap_tfe\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mTFE_Py_Execute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_handle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mop_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 54\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 55\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_NotOkStatusException \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m 56\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "# train mnist\n", + "\n", + "mnist = tf.keras.datasets.mnist\n", + "(train_images0, train_labels0), (test_images0, test_labels0) = mnist.load_data()\n", + "\n", + "test_images = test_images0.reshape(10000, 28, 28)\n", + "train_images = train_images0.reshape(60000, 28, 28)\n", + "\n", + "test_images = test_images/255.0\n", + "train_images = train_images/255.0\n", + "\n", + "keras_model = tf.keras.models.Sequential([\n", + " layers.Conv2D(8, (2, 2), activation='relu', input_shape=(28, 28, 1)),\n", + " layers.MaxPooling2D((2, 2)),\n", + " layers.Conv2D(16, (2, 2), activation='relu'),\n", + " layers.MaxPooling2D((2, 2)),\n", + " layers.Flatten(),\n", + " layers.Dense(10, activation='softmax')\n", + "])\n", + "\n", + "keras_model.build(input_shape=[None,784])\n", + "\n", + "keras_model.summary()\n", + "\n", + "keras_model.compile(\n", + " optimizer=tf.keras.optimizers.SGD(0.2),\n", + " loss=tf.keras.losses.CategoricalHinge(),\n", + " metrics=[tf.keras.metrics.SparseCategoricalAccuracy()],\n", + ")\n", + "\n", + "# Train loop\n", + "history = keras_model.fit(\n", + " train_images,\n", + " train_labels0,\n", + " batch_size=len(train_images),\n", + " epochs=200,\n", + " validation_data=(test_images, test_labels0),\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Key: loss\n", + "Key: sparse_categorical_accuracy\n", + "Key: val_loss\n", + "Key: val_sparse_categorical_accuracy\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# vizualize mnist\n", + "\n", + "for item in history.history:\n", + " print(\"Key:\",item)\n", + "\n", + "plt.plot(history.history['loss'],label=\"train\")\n", + "plt.plot(history.history['val_loss'],label=\"validation\")\n", + "plt.title('Model Loss')\n", + "plt.yscale('log')\n", + "plt.ylabel('Cross Entropy')\n", + "plt.xlabel('Iteration')\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "#print(\"history\",history.history)\n", + "plt.plot(history.history['sparse_categorical_accuracy'],label=\"train\")\n", + "plt.plot(history.history['val_sparse_categorical_accuracy'],label=\"validation\")\n", + "plt.title('Model Accuracy')\n", + "#plt.yscale('log')\n", + "plt.ylabel('Acc')\n", + "plt.xlabel('Iteration')\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3.\n", + "\n", + "Palyginkite savarankiškai adaptuotą kodą su Lab31.\n", + "\n", + "Mano variantas yra daug lėtis ir blogesnis, su laiko mano tikslumas mažėja." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.\n", + "\n", + "Išmėginkite keletą tinklo architektūrų ir mokymosi parametrų." + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_37\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " conv2d_77 (Conv2D) (None, 26, 26, 28) 280 \n", + " \n", + " dropout_42 (Dropout) (None, 26, 26, 28) 0 \n", + " \n", + " max_pooling2d_52 (MaxPooli (None, 13, 13, 28) 0 \n", + " ng2D) \n", + " \n", + " conv2d_78 (Conv2D) (None, 11, 11, 32) 8096 \n", + " \n", + " dropout_43 (Dropout) (None, 11, 11, 32) 0 \n", + " \n", + " max_pooling2d_53 (MaxPooli (None, 5, 5, 32) 0 \n", + " ng2D) \n", + " \n", + " conv2d_79 (Conv2D) (None, 3, 3, 32) 9248 \n", + " \n", + " dropout_44 (Dropout) (None, 3, 3, 32) 0 \n", + " \n", + " max_pooling2d_54 (MaxPooli (None, 1, 1, 32) 0 \n", + " ng2D) \n", + " \n", + " flatten_36 (Flatten) (None, 32) 0 \n", + " \n", + " dense_79 (Dense) (None, 64) 2112 \n", + " \n", + " dense_80 (Dense) (None, 10) 650 \n", + " \n", + "=================================================================\n", + "Total params: 20386 (79.63 KB)\n", + "Trainable params: 20386 (79.63 KB)\n", + "Non-trainable params: 0 (0.00 Byte)\n", + "_________________________________________________________________\n", + "Epoch 1/20\n", + "1875/1875 [==============================] - 13s 7ms/step - loss: 1.0415 - sparse_categorical_accuracy: 0.6445 - val_loss: 1.2608 - val_sparse_categorical_accuracy: 0.9006\n", + "Epoch 2/20\n", + "1875/1875 [==============================] - 13s 7ms/step - loss: 0.5399 - sparse_categorical_accuracy: 0.8257 - val_loss: 1.1064 - val_sparse_categorical_accuracy: 0.9159\n", + "Epoch 3/20\n", + "1875/1875 [==============================] - 11s 6ms/step - loss: 0.4214 - sparse_categorical_accuracy: 0.8656 - val_loss: 0.8521 - val_sparse_categorical_accuracy: 0.9504\n", + "Epoch 4/20\n", + "1875/1875 [==============================] - 12s 6ms/step - loss: 0.3621 - sparse_categorical_accuracy: 0.8860 - val_loss: 0.8352 - val_sparse_categorical_accuracy: 0.9386\n", + "Epoch 5/20\n", + "1875/1875 [==============================] - 14s 7ms/step - loss: 0.3244 - sparse_categorical_accuracy: 0.8982 - val_loss: 0.7719 - val_sparse_categorical_accuracy: 0.9237\n", + "Epoch 6/20\n", + "1875/1875 [==============================] - 12s 6ms/step - loss: 0.2937 - sparse_categorical_accuracy: 0.9093 - val_loss: 0.7067 - val_sparse_categorical_accuracy: 0.9461\n", + "Epoch 7/20\n", + "1875/1875 [==============================] - 11s 6ms/step - loss: 0.2752 - sparse_categorical_accuracy: 0.9154 - val_loss: 0.6561 - val_sparse_categorical_accuracy: 0.9558\n", + "Epoch 8/20\n", + "1875/1875 [==============================] - 11s 6ms/step - loss: 0.2633 - sparse_categorical_accuracy: 0.9182 - val_loss: 0.6981 - val_sparse_categorical_accuracy: 0.9540\n", + "Epoch 9/20\n", + "1875/1875 [==============================] - 11s 6ms/step - loss: 0.2484 - sparse_categorical_accuracy: 0.9235 - val_loss: 0.6180 - val_sparse_categorical_accuracy: 0.9490\n", + "Epoch 10/20\n", + "1875/1875 [==============================] - 11s 6ms/step - loss: 0.2417 - sparse_categorical_accuracy: 0.9252 - val_loss: 0.6084 - val_sparse_categorical_accuracy: 0.9554\n", + "Epoch 11/20\n", + "1875/1875 [==============================] - 11s 6ms/step - loss: 0.2332 - sparse_categorical_accuracy: 0.9284 - val_loss: 0.6027 - val_sparse_categorical_accuracy: 0.9597\n", + "Epoch 12/20\n", + "1875/1875 [==============================] - 11s 6ms/step - loss: 0.2304 - sparse_categorical_accuracy: 0.9287 - val_loss: 0.5875 - val_sparse_categorical_accuracy: 0.9547\n", + "Epoch 13/20\n", + "1875/1875 [==============================] - 11s 6ms/step - loss: 0.2217 - sparse_categorical_accuracy: 0.9315 - val_loss: 0.5443 - val_sparse_categorical_accuracy: 0.9643\n", + "Epoch 14/20\n", + "1875/1875 [==============================] - 11s 6ms/step - loss: 0.2142 - sparse_categorical_accuracy: 0.9329 - val_loss: 0.5337 - val_sparse_categorical_accuracy: 0.9641\n", + "Epoch 15/20\n", + "1875/1875 [==============================] - 11s 6ms/step - loss: 0.2129 - sparse_categorical_accuracy: 0.9346 - val_loss: 0.5420 - val_sparse_categorical_accuracy: 0.9625\n", + "Epoch 16/20\n", + "1875/1875 [==============================] - 11s 6ms/step - loss: 0.2060 - sparse_categorical_accuracy: 0.9365 - val_loss: 0.5098 - val_sparse_categorical_accuracy: 0.9650\n", + "Epoch 17/20\n", + "1875/1875 [==============================] - 11s 6ms/step - loss: 0.2029 - sparse_categorical_accuracy: 0.9361 - val_loss: 0.5653 - val_sparse_categorical_accuracy: 0.9631\n", + "Epoch 18/20\n", + "1875/1875 [==============================] - 12s 6ms/step - loss: 0.2015 - sparse_categorical_accuracy: 0.9377 - val_loss: 0.5545 - val_sparse_categorical_accuracy: 0.9608\n", + "Epoch 19/20\n", + "1875/1875 [==============================] - 11s 6ms/step - loss: 0.1964 - sparse_categorical_accuracy: 0.9391 - val_loss: 0.5276 - val_sparse_categorical_accuracy: 0.9645\n", + "Epoch 20/20\n", + "1875/1875 [==============================] - 11s 6ms/step - loss: 0.1960 - sparse_categorical_accuracy: 0.9396 - val_loss: 0.5144 - val_sparse_categorical_accuracy: 0.9613\n" + ] + } + ], + "source": [ + "mnist = tf.keras.datasets.mnist\n", + "(train_images0, train_labels0), (test_images0, test_labels0) = mnist.load_data()\n", + "\n", + "test_images=test_images0\n", + "train_images=train_images0\n", + "\n", + "test_images = test_images/255.0\n", + "train_images = train_images/255.0\n", + "\n", + "keras_model = tf.keras.models.Sequential([\n", + " tf.keras.layers.Conv2D(28, (3, 3), activation='relu', input_shape=(28, 28, 1)),\n", + " tf.keras.layers.Dropout(.6, input_shape=(2,)),\n", + " tf.keras.layers.MaxPooling2D(2, 2),\n", + "\n", + " tf.keras.layers.Conv2D(32, (3, 3), activation='relu'),\n", + " tf.keras.layers.Dropout(.6, input_shape=(2,)),\n", + " tf.keras.layers.MaxPooling2D((2, 2)),\n", + "\n", + " tf.keras.layers.Conv2D(32, (3, 3), activation='relu'),\n", + " tf.keras.layers.Dropout(.6, input_shape=(2,)),\n", + " tf.keras.layers.MaxPooling2D((2, 2)),\n", + "\n", + "\n", + " tf.keras.layers.Flatten(),\n", + " tf.keras.layers.Dense(64, activation='relu'),\n", + " tf.keras.layers.Dense(10, activation='softmax')\n", + "])\n", + "\n", + "keras_model.build(input_shape=[None,784])\n", + "\n", + "keras_model.summary()\n", + "\n", + "keras_model.compile(\n", + " optimizer=tf.keras.optimizers.SGD(0.02),\n", + " loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),\n", + " metrics=[tf.keras.metrics.SparseCategoricalAccuracy()],\n", + ")\n", + "\n", + "# Train loop\n", + "history = keras_model.fit(\n", + " train_images,\n", + " train_labels0,\n", + " batch_size=100,\n", + " epochs=20,\n", + " validation_data=(test_images, test_labels0),\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Key: loss\n", + "Key: sparse_categorical_accuracy\n", + "Key: val_loss\n", + "Key: val_sparse_categorical_accuracy\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# vizualize mnist\n", + "\n", + "for item in history.history:\n", + " print(\"Key:\",item)\n", + "\n", + "plt.plot(history.history['loss'],label=\"train\")\n", + "plt.plot(history.history['val_loss'],label=\"validation\")\n", + "plt.title('Model Loss')\n", + "plt.yscale('log')\n", + "plt.ylabel('Cross Entropy')\n", + "plt.xlabel('Iteration')\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "#print(\"history\",history.history)\n", + "plt.plot(history.history['sparse_categorical_accuracy'],label=\"train\")\n", + "plt.plot(history.history['val_sparse_categorical_accuracy'],label=\"validation\")\n", + "plt.title('Model Accuracy')\n", + "#plt.yscale('log')\n", + "plt.ylabel('Acc')\n", + "plt.xlabel('Iteration')\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.\n", + "\n", + "Esant persimokymui papildykite modelius Dropout sluoksniais.\n", + "\n", + "Ats.:\n", + "Neatrodo, kad yra persimokymas. Atrodo, kad kažkas atvirkčia persimokymo vyksta, stipriai pakėlus \"Dropout\" validacijos tikslumas yra ženkliai aukštesnis negu mokymosi. Kodėl?\n", + "\n", + "Kas dar vyksta didinant \"Dropout\" tai maksimalus mokymosi tikslumas žemėja šiek tiek." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6.\n", + "\n", + "Palyginkite Lab24 MNIST ir architektūros su konvoliuciniais sluoksniais tikslumą bei mokymosi greitį MNIST duomenims.\n", + "\n", + "Ats.: Mokymosi laikas ženkliai pailgėja, bet dėsningumus ir sąryšius kuriuos mokymose proceses gali išmokti atstoją ilgesnį mokymasi.\n", + "\n", + "Jeigu reikia greičio gali naudoti \"Batching\", kad pagreitinti mokymasi." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Lab32" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1.\n", + "\n", + "Realizuoti LeNet architektūrą ir pritaikyti MNIST duomenims." + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_36\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " zero_padding2d_8 (ZeroPadd (None, 32, 32, 1) 0 \n", + " ing2D) \n", + " \n", + " conv2d_75 (Conv2D) (None, 28, 28, 6) 156 \n", + " \n", + " average_pooling2d_16 (Aver (None, 14, 14, 6) 0 \n", + " agePooling2D) \n", + " \n", + " conv2d_76 (Conv2D) (None, 10, 10, 16) 2416 \n", + " \n", + " average_pooling2d_17 (Aver (None, 5, 5, 16) 0 \n", + " agePooling2D) \n", + " \n", + " flatten_35 (Flatten) (None, 400) 0 \n", + " \n", + " dense_76 (Dense) (None, 120) 48120 \n", + " \n", + " dense_77 (Dense) (None, 84) 10164 \n", + " \n", + " dense_78 (Dense) (None, 10) 850 \n", + " \n", + "=================================================================\n", + "Total params: 61706 (241.04 KB)\n", + "Trainable params: 61706 (241.04 KB)\n", + "Non-trainable params: 0 (0.00 Byte)\n", + "_________________________________________________________________\n", + "Epoch 1/20\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "f:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\keras\\src\\backend.py:5727: UserWarning: \"`sparse_categorical_crossentropy` received `from_logits=True`, but the `output` argument was produced by a Softmax activation and thus does not represent logits. Was this intended?\n", + " output, from_logits = _get_logits(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "600/600 [==============================] - 3s 4ms/step - loss: 2.3026 - sparse_categorical_accuracy: 0.1172 - val_loss: 2.2874 - val_sparse_categorical_accuracy: 0.1135\n", + "Epoch 2/20\n", + "600/600 [==============================] - 2s 4ms/step - loss: 2.1563 - sparse_categorical_accuracy: 0.3599 - val_loss: 1.7558 - val_sparse_categorical_accuracy: 0.6306\n", + "Epoch 3/20\n", + "600/600 [==============================] - 2s 3ms/step - loss: 1.2294 - sparse_categorical_accuracy: 0.7310 - val_loss: 0.8575 - val_sparse_categorical_accuracy: 0.8134\n", + "Epoch 4/20\n", + "600/600 [==============================] - 2s 3ms/step - loss: 0.7044 - sparse_categorical_accuracy: 0.8393 - val_loss: 0.5652 - val_sparse_categorical_accuracy: 0.8741\n", + "Epoch 5/20\n", + "600/600 [==============================] - 2s 4ms/step - loss: 0.5064 - sparse_categorical_accuracy: 0.8783 - val_loss: 0.4372 - val_sparse_categorical_accuracy: 0.8958\n", + "Epoch 6/20\n", + "600/600 [==============================] - 3s 4ms/step - loss: 0.4106 - sparse_categorical_accuracy: 0.8958 - val_loss: 0.3699 - val_sparse_categorical_accuracy: 0.9074\n", + "Epoch 7/20\n", + "600/600 [==============================] - 2s 4ms/step - loss: 0.3561 - sparse_categorical_accuracy: 0.9062 - val_loss: 0.3270 - val_sparse_categorical_accuracy: 0.9136\n", + "Epoch 8/20\n", + "600/600 [==============================] - 2s 4ms/step - loss: 0.3199 - sparse_categorical_accuracy: 0.9138 - val_loss: 0.2981 - val_sparse_categorical_accuracy: 0.9195\n", + "Epoch 9/20\n", + "600/600 [==============================] - 3s 4ms/step - loss: 0.2928 - sparse_categorical_accuracy: 0.9196 - val_loss: 0.2759 - val_sparse_categorical_accuracy: 0.9266\n", + "Epoch 10/20\n", + "600/600 [==============================] - 2s 4ms/step - loss: 0.2721 - sparse_categorical_accuracy: 0.9248 - val_loss: 0.2574 - val_sparse_categorical_accuracy: 0.9306\n", + "Epoch 11/20\n", + "600/600 [==============================] - 2s 4ms/step - loss: 0.2553 - sparse_categorical_accuracy: 0.9294 - val_loss: 0.2401 - val_sparse_categorical_accuracy: 0.9341\n", + "Epoch 12/20\n", + "600/600 [==============================] - 2s 4ms/step - loss: 0.2411 - sparse_categorical_accuracy: 0.9320 - val_loss: 0.2274 - val_sparse_categorical_accuracy: 0.9382\n", + "Epoch 13/20\n", + "600/600 [==============================] - 2s 4ms/step - loss: 0.2287 - sparse_categorical_accuracy: 0.9370 - val_loss: 0.2179 - val_sparse_categorical_accuracy: 0.9387\n", + "Epoch 14/20\n", + "600/600 [==============================] - 2s 4ms/step - loss: 0.2178 - sparse_categorical_accuracy: 0.9388 - val_loss: 0.2090 - val_sparse_categorical_accuracy: 0.9421\n", + "Epoch 15/20\n", + "600/600 [==============================] - 2s 4ms/step - loss: 0.2082 - sparse_categorical_accuracy: 0.9408 - val_loss: 0.1997 - val_sparse_categorical_accuracy: 0.9441\n", + "Epoch 16/20\n", + "600/600 [==============================] - 2s 4ms/step - loss: 0.1997 - sparse_categorical_accuracy: 0.9435 - val_loss: 0.1935 - val_sparse_categorical_accuracy: 0.9463\n", + "Epoch 17/20\n", + "600/600 [==============================] - 2s 4ms/step - loss: 0.1918 - sparse_categorical_accuracy: 0.9452 - val_loss: 0.1856 - val_sparse_categorical_accuracy: 0.9492\n", + "Epoch 18/20\n", + "600/600 [==============================] - 2s 4ms/step - loss: 0.1846 - sparse_categorical_accuracy: 0.9479 - val_loss: 0.1802 - val_sparse_categorical_accuracy: 0.9498\n", + "Epoch 19/20\n", + "600/600 [==============================] - 2s 4ms/step - loss: 0.1783 - sparse_categorical_accuracy: 0.9494 - val_loss: 0.1744 - val_sparse_categorical_accuracy: 0.9508\n", + "Epoch 20/20\n", + "600/600 [==============================] - 2s 4ms/step - loss: 0.1725 - sparse_categorical_accuracy: 0.9507 - val_loss: 0.1691 - val_sparse_categorical_accuracy: 0.9527\n" + ] + } + ], + "source": [ + "mnist = tf.keras.datasets.mnist\n", + "(train_images0, train_labels0), (test_images0, test_labels0) = mnist.load_data()\n", + "\n", + "test_images=test_images0\n", + "train_images=train_images0\n", + "\n", + "test_images = test_images/255.0\n", + "train_images = train_images/255.0\n", + "\n", + "keras_model = tf.keras.models.Sequential([\n", + " layers.ZeroPadding2D(padding=(2,2), input_shape=(28, 28, 1)),\n", + " layers.Conv2D(6, (5, 5), activation='relu'),\n", + " layers.AveragePooling2D((2, 2), strides = 2),\n", + " layers.Conv2D(16, (5, 5)),\n", + " layers.AveragePooling2D((2, 2), strides = 2),\n", + "\n", + " layers.Flatten(),\n", + " layers.Dense(120, activation='sigmoid'),\n", + " layers.Dense(84, activation='sigmoid'),\n", + " layers.Dense(10, activation='sigmoid')\n", + "])\n", + "\n", + "keras_model.build(input_shape=[None,784])\n", + "\n", + "keras_model.summary()\n", + "\n", + "keras_model.compile(\n", + " optimizer=tf.keras.optimizers.SGD(0.02),\n", + " loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n", + " metrics=[tf.keras.metrics.SparseCategoricalAccuracy()],\n", + ")\n", + "\n", + "# Train loop\n", + "history = keras_model.fit(\n", + " train_images,\n", + " train_labels0,\n", + " batch_size=100,\n", + " epochs=20,\n", + " validation_data=(test_images, test_labels0),\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Key: loss\n", + "Key: sparse_categorical_accuracy\n", + "Key: val_loss\n", + "Key: val_sparse_categorical_accuracy\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# vizualize mnist\n", + "\n", + "for item in history.history:\n", + " print(\"Key:\",item)\n", + "\n", + "plt.plot(history.history['loss'],label=\"train\")\n", + "plt.plot(history.history['val_loss'],label=\"validation\")\n", + "plt.title('Model Loss')\n", + "plt.yscale('log')\n", + "plt.ylabel('Cross Entropy')\n", + "plt.xlabel('Iteration')\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "#print(\"history\",history.history)\n", + "plt.plot(history.history['sparse_categorical_accuracy'],label=\"train\")\n", + "plt.plot(history.history['val_sparse_categorical_accuracy'],label=\"validation\")\n", + "plt.title('Model Accuracy')\n", + "#plt.yscale('log')\n", + "plt.ylabel('Acc')\n", + "plt.xlabel('Iteration')\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2.\n", + "\n", + "Realizuoti ResNet tinklą ir palyginti su konvoliuciniu tinklu be liekamųjų ryšių." + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "235/235 [==============================] - 74s 306ms/step - loss: 0.7743 - accuracy: 0.7702 - val_loss: 0.4372 - val_accuracy: 0.8668\n", + "Epoch 2/10\n", + "235/235 [==============================] - 72s 308ms/step - loss: 0.3905 - accuracy: 0.8771 - val_loss: 0.3402 - val_accuracy: 0.8938\n", + "Epoch 3/10\n", + "235/235 [==============================] - 71s 302ms/step - loss: 0.3226 - accuracy: 0.8979 - val_loss: 0.2689 - val_accuracy: 0.9129\n", + "Epoch 4/10\n", + "235/235 [==============================] - 74s 317ms/step - loss: 0.2788 - accuracy: 0.9112 - val_loss: 0.2699 - val_accuracy: 0.9119\n", + "Epoch 5/10\n", + "235/235 [==============================] - 70s 299ms/step - loss: 0.2666 - accuracy: 0.9151 - val_loss: 0.2245 - val_accuracy: 0.9277\n", + "Epoch 6/10\n", + "235/235 [==============================] - 70s 300ms/step - loss: 0.2364 - accuracy: 0.9244 - val_loss: 0.2107 - val_accuracy: 0.9305\n", + "Epoch 7/10\n", + "235/235 [==============================] - 70s 299ms/step - loss: 0.2248 - accuracy: 0.9284 - val_loss: 0.2309 - val_accuracy: 0.9260\n", + "Epoch 8/10\n", + "235/235 [==============================] - 75s 318ms/step - loss: 0.2125 - accuracy: 0.9319 - val_loss: 0.2109 - val_accuracy: 0.9304\n", + "Epoch 9/10\n", + "235/235 [==============================] - 73s 312ms/step - loss: 0.2070 - accuracy: 0.9337 - val_loss: 0.2505 - val_accuracy: 0.9124\n", + "Epoch 10/10\n", + "235/235 [==============================] - 76s 322ms/step - loss: 0.1955 - accuracy: 0.9379 - val_loss: 0.1950 - val_accuracy: 0.9356\n" + ] + } + ], + "source": [ + "from tensorflow.keras import datasets, layers, models, losses, Model\n", + "\n", + "mnist = tf.keras.datasets.mnist\n", + "\n", + "(train_images0, train_labels0),(test_images0,test_labels0) = datasets.mnist.load_data()\n", + "train_images0 = tf.pad(train_images0, [[0, 0], [2,2], [2,2]])/255\n", + "test_images0 = tf.pad(test_images0, [[0, 0], [2,2], [2,2]])/255\n", + "train_images0 = tf.expand_dims(train_images0, axis=3, name=None)\n", + "test_images0 = tf.expand_dims(test_images0, axis=3, name=None)\n", + "train_images0 = tf.repeat(train_images0, 3, axis=3)\n", + "test_images0 = tf.repeat(test_images0, 3, axis=3)\n", + "\n", + "test_images = test_images0\n", + "train_images = train_images0\n", + "\n", + "base_model = tf.keras.applications.ResNet50(weights = 'imagenet', include_top = False, input_shape = (32,32,3))\n", + "\n", + "for layer in base_model.layers:\n", + " layer.trainable = False\n", + "\n", + "x = layers.Flatten()(base_model.output)\n", + "x = layers.Dense(1000, activation='relu')(x)\n", + "predictions = layers.Dense(10, activation = 'softmax')(x)\n", + "\n", + "head_model = Model(inputs = base_model.input, outputs = predictions)\n", + "head_model.compile(optimizer='adam', loss=losses.sparse_categorical_crossentropy, metrics=['accuracy'])\n", + "\n", + "history = head_model.fit(train_images, train_labels0, batch_size=256, epochs=10, validation_data=(test_images, test_labels0))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Key: loss\n", + "Key: accuracy\n", + "Key: val_loss\n", + "Key: val_accuracy\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# vizualize mnist\n", + "\n", + "for item in history.history:\n", + " print(\"Key:\",item)\n", + "\n", + "plt.plot(history.history['loss'],label=\"train\")\n", + "plt.plot(history.history['val_loss'],label=\"validation\")\n", + "plt.title('Model Loss')\n", + "plt.yscale('log')\n", + "plt.ylabel('Cross Entropy')\n", + "plt.xlabel('Iteration')\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "#print(\"history\",history.history)\n", + "plt.plot(history.history['accuracy'],label=\"train\")\n", + "plt.plot(history.history['val_accuracy'],label=\"validation\")\n", + "plt.title('Model Accuracy')\n", + "#plt.yscale('log')\n", + "plt.ylabel('Acc')\n", + "plt.xlabel('Iteration')\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3.\n", + "\n", + "Realizuoti U-Net tinklą." + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:`input_shape` is undefined or non-square, or `rows` is not in [96, 128, 160, 192, 224]. Weights for input shape (224, 224) will be loaded as the default.\n", + "Epoch 1/20\n", + "101/938 [==>...........................] - ETA: 3:20 - loss: 12.1178 - accuracy: 0.5198" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[100], line 69\u001b[0m\n\u001b[0;32m 61\u001b[0m model\u001b[38;5;241m.\u001b[39mcompile(\n\u001b[0;32m 62\u001b[0m optimizer\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124madam\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[0;32m 63\u001b[0m loss\u001b[38;5;241m=\u001b[39mtf\u001b[38;5;241m.\u001b[39mkeras\u001b[38;5;241m.\u001b[39mlosses\u001b[38;5;241m.\u001b[39mSparseCategoricalCrossentropy(from_logits\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m),\n\u001b[0;32m 64\u001b[0m metrics\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124maccuracy\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[0;32m 65\u001b[0m )\n\u001b[0;32m 67\u001b[0m \u001b[38;5;66;03m#tf.keras.utils.plot_model(model, show_shapes=True)\u001b[39;00m\n\u001b[1;32m---> 69\u001b[0m model_history \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 70\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrain_images\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_labels0\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 71\u001b[0m \u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m20\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 72\u001b[0m \u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m64\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 73\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtest_images\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest_labels0\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 74\u001b[0m \u001b[43m)\u001b[49m\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\keras\\src\\utils\\traceback_utils.py:65\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 63\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m 64\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m---> 65\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 66\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m 67\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\keras\\src\\engine\\training.py:1807\u001b[0m, in \u001b[0;36mModel.fit\u001b[1;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[0;32m 1799\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m tf\u001b[38;5;241m.\u001b[39mprofiler\u001b[38;5;241m.\u001b[39mexperimental\u001b[38;5;241m.\u001b[39mTrace(\n\u001b[0;32m 1800\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtrain\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m 1801\u001b[0m epoch_num\u001b[38;5;241m=\u001b[39mepoch,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1804\u001b[0m _r\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m,\n\u001b[0;32m 1805\u001b[0m ):\n\u001b[0;32m 1806\u001b[0m callbacks\u001b[38;5;241m.\u001b[39mon_train_batch_begin(step)\n\u001b[1;32m-> 1807\u001b[0m tmp_logs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrain_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43miterator\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1808\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m data_handler\u001b[38;5;241m.\u001b[39mshould_sync:\n\u001b[0;32m 1809\u001b[0m context\u001b[38;5;241m.\u001b[39masync_wait()\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\util\\traceback_utils.py:150\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 148\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m 149\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 150\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 151\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m 152\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\polymorphic_function.py:832\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m 829\u001b[0m compiler \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mxla\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnonXla\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 831\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m OptionalXlaContext(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile):\n\u001b[1;32m--> 832\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 834\u001b[0m new_tracing_count \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexperimental_get_tracing_count()\n\u001b[0;32m 835\u001b[0m without_tracing \u001b[38;5;241m=\u001b[39m (tracing_count \u001b[38;5;241m==\u001b[39m new_tracing_count)\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\polymorphic_function.py:868\u001b[0m, in \u001b[0;36mFunction._call\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m 865\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n\u001b[0;32m 866\u001b[0m \u001b[38;5;66;03m# In this case we have created variables on the first call, so we run the\u001b[39;00m\n\u001b[0;32m 867\u001b[0m \u001b[38;5;66;03m# defunned version which is guaranteed to never create variables.\u001b[39;00m\n\u001b[1;32m--> 868\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtracing_compilation\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 869\u001b[0m \u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_no_variable_creation_config\u001b[49m\n\u001b[0;32m 870\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 871\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_variable_creation_config \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 872\u001b[0m \u001b[38;5;66;03m# Release the lock early so that multiple threads can perform the call\u001b[39;00m\n\u001b[0;32m 873\u001b[0m \u001b[38;5;66;03m# in parallel.\u001b[39;00m\n\u001b[0;32m 874\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\tracing_compilation.py:139\u001b[0m, in \u001b[0;36mcall_function\u001b[1;34m(args, kwargs, tracing_options)\u001b[0m\n\u001b[0;32m 137\u001b[0m bound_args \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mbind(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m 138\u001b[0m flat_inputs \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39munpack_inputs(bound_args)\n\u001b[1;32m--> 139\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# pylint: disable=protected-access\u001b[39;49;00m\n\u001b[0;32m 140\u001b[0m \u001b[43m \u001b[49m\u001b[43mflat_inputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcaptured_inputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcaptured_inputs\u001b[49m\n\u001b[0;32m 141\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\concrete_function.py:1323\u001b[0m, in \u001b[0;36mConcreteFunction._call_flat\u001b[1;34m(self, tensor_inputs, captured_inputs)\u001b[0m\n\u001b[0;32m 1319\u001b[0m possible_gradient_type \u001b[38;5;241m=\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPossibleTapeGradientTypes(args)\n\u001b[0;32m 1320\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (possible_gradient_type \u001b[38;5;241m==\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPOSSIBLE_GRADIENT_TYPES_NONE\n\u001b[0;32m 1321\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m executing_eagerly):\n\u001b[0;32m 1322\u001b[0m \u001b[38;5;66;03m# No tape is watching; skip to running the function.\u001b[39;00m\n\u001b[1;32m-> 1323\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_inference_function\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_preflattened\u001b[49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1324\u001b[0m forward_backward \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_select_forward_and_backward_functions(\n\u001b[0;32m 1325\u001b[0m args,\n\u001b[0;32m 1326\u001b[0m possible_gradient_type,\n\u001b[0;32m 1327\u001b[0m executing_eagerly)\n\u001b[0;32m 1328\u001b[0m forward_function, args_with_tangents \u001b[38;5;241m=\u001b[39m forward_backward\u001b[38;5;241m.\u001b[39mforward()\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\atomic_function.py:216\u001b[0m, in \u001b[0;36mAtomicFunction.call_preflattened\u001b[1;34m(self, args)\u001b[0m\n\u001b[0;32m 214\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcall_preflattened\u001b[39m(\u001b[38;5;28mself\u001b[39m, args: Sequence[core\u001b[38;5;241m.\u001b[39mTensor]) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[0;32m 215\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Calls with flattened tensor inputs and returns the structured output.\"\"\"\u001b[39;00m\n\u001b[1;32m--> 216\u001b[0m flat_outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 217\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mpack_output(flat_outputs)\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\atomic_function.py:251\u001b[0m, in \u001b[0;36mAtomicFunction.call_flat\u001b[1;34m(self, *args)\u001b[0m\n\u001b[0;32m 249\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m record\u001b[38;5;241m.\u001b[39mstop_recording():\n\u001b[0;32m 250\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mexecuting_eagerly():\n\u001b[1;32m--> 251\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_bound_context\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 252\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 253\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 254\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunction_type\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mflat_outputs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 255\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 256\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 257\u001b[0m outputs \u001b[38;5;241m=\u001b[39m make_call_op_in_graph(\n\u001b[0;32m 258\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 259\u001b[0m \u001b[38;5;28mlist\u001b[39m(args),\n\u001b[0;32m 260\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mfunction_call_options\u001b[38;5;241m.\u001b[39mas_attrs(),\n\u001b[0;32m 261\u001b[0m )\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\context.py:1486\u001b[0m, in \u001b[0;36mContext.call_function\u001b[1;34m(self, name, tensor_inputs, num_outputs)\u001b[0m\n\u001b[0;32m 1484\u001b[0m cancellation_context \u001b[38;5;241m=\u001b[39m cancellation\u001b[38;5;241m.\u001b[39mcontext()\n\u001b[0;32m 1485\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cancellation_context \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m-> 1486\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mexecute\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 1487\u001b[0m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecode\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mutf-8\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1488\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_outputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1489\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtensor_inputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1490\u001b[0m \u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1491\u001b[0m \u001b[43m \u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1492\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1493\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 1494\u001b[0m outputs \u001b[38;5;241m=\u001b[39m execute\u001b[38;5;241m.\u001b[39mexecute_with_cancellation(\n\u001b[0;32m 1495\u001b[0m name\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mutf-8\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[0;32m 1496\u001b[0m num_outputs\u001b[38;5;241m=\u001b[39mnum_outputs,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1500\u001b[0m cancellation_manager\u001b[38;5;241m=\u001b[39mcancellation_context,\n\u001b[0;32m 1501\u001b[0m )\n", + "File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\execute.py:53\u001b[0m, in \u001b[0;36mquick_execute\u001b[1;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[0;32m 51\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m 52\u001b[0m ctx\u001b[38;5;241m.\u001b[39mensure_initialized()\n\u001b[1;32m---> 53\u001b[0m tensors \u001b[38;5;241m=\u001b[39m \u001b[43mpywrap_tfe\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mTFE_Py_Execute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_handle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mop_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 54\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 55\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_NotOkStatusException \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m 56\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "#https://www.tensorflow.org/tutorials/images/segmentation\n", + "\n", + "import pix2pix\n", + "\n", + "(train_images0, train_labels0),(test_images0,test_labels0) = datasets.mnist.load_data()\n", + "train_images0 = tf.pad(train_images0, [[0, 0], [2,2], [2,2]])/255\n", + "test_images0 = tf.pad(test_images0, [[0, 0], [2,2], [2,2]])/255\n", + "train_images0 = tf.expand_dims(train_images0, axis=3, name=None)\n", + "test_images0 = tf.expand_dims(test_images0, axis=3, name=None)\n", + "train_images0 = tf.repeat(train_images0, 3, axis=3)\n", + "test_images0 = tf.repeat(test_images0, 3, axis=3)\n", + "\n", + "test_images = test_images0\n", + "train_images = train_images0\n", + "\n", + "base_model = tf.keras.applications.MobileNetV2(input_shape=[32, 32, 3], include_top=False)\n", + "\n", + "# Use the activations of these layers\n", + "layer_names = [\n", + " 'block_1_expand_relu', # 64x64\n", + " 'block_3_expand_relu', # 32x32\n", + " 'block_6_expand_relu', # 16x16\n", + " 'block_13_expand_relu', # 8x8\n", + " 'block_16_project', # 4x4\n", + "]\n", + "base_model_outputs = [base_model.get_layer(name).output for name in layer_names]\n", + "\n", + "# Create the feature extraction model\n", + "down_stack = tf.keras.Model(inputs=base_model.input, outputs=base_model_outputs)\n", + "\n", + "down_stack.trainable = False\n", + "\n", + "up_stack = [\n", + " pix2pix.upsample(512, 3), # 4x4 -> 8x8\n", + " pix2pix.upsample(256, 3), # 8x8 -> 16x16\n", + " pix2pix.upsample(128, 3), # 16x16 -> 32x32\n", + " pix2pix.upsample(64, 3), # 32x32 -> 64x64\n", + "]\n", + "\n", + "def unet_model(output_channels:int):\n", + " inputs = tf.keras.layers.Input(shape=[32, 32, 3])\n", + "\n", + " # Downsampling through the model\n", + " skips = down_stack(inputs)\n", + " x = skips[-1]\n", + " skips = reversed(skips[:-1])\n", + "\n", + " # Upsampling and establishing the skip connections\n", + " for up, skip in zip(up_stack, skips):\n", + " x = up(x)\n", + " concat = tf.keras.layers.Concatenate()\n", + " x = concat([x, skip])\n", + "\n", + " x = layers.Flatten()(x)\n", + " x = layers.Dense(128, activation='relu')(x)\n", + " x = layers.Dense(10, activation = 'softmax')(x)\n", + "\n", + " return tf.keras.Model(inputs=inputs, outputs=x)\n", + "\n", + "model = unet_model(output_channels=10)\n", + "model.compile(\n", + " optimizer='adam',\n", + " loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),\n", + " metrics=['accuracy']\n", + ")\n", + "\n", + "#tf.keras.utils.plot_model(model, show_shapes=True)\n", + "\n", + "model_history = model.fit(\n", + " train_images, train_labels0,\n", + " epochs=20,\n", + " batch_size=64,\n", + " validation_data=(test_images, test_labels0)\n", + ")" + ] } ], "metadata": { diff --git a/Lab2/pix2pix.py b/Lab2/pix2pix.py new file mode 100644 index 0000000..6ce4098 --- /dev/null +++ b/Lab2/pix2pix.py @@ -0,0 +1,508 @@ +# Copyright 2019 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Pix2pix. +""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import os +import time +from absl import app +from absl import flags + +import tensorflow as tf + +FLAGS = flags.FLAGS + +flags.DEFINE_integer('buffer_size', 400, 'Shuffle buffer size') +flags.DEFINE_integer('batch_size', 1, 'Batch Size') +flags.DEFINE_integer('epochs', 1, 'Number of epochs') +flags.DEFINE_string('path', None, 'Path to the data folder') +flags.DEFINE_boolean('enable_function', True, 'Enable Function?') + +IMG_WIDTH = 256 +IMG_HEIGHT = 256 +AUTOTUNE = tf.data.experimental.AUTOTUNE + + +def load(image_file): + """Loads the image and generates input and target image. + + Args: + image_file: .jpeg file + + Returns: + Input image, target image + """ + image = tf.io.read_file(image_file) + image = tf.image.decode_jpeg(image) + + w = tf.shape(image)[1] + + w = w // 2 + real_image = image[:, :w, :] + input_image = image[:, w:, :] + + input_image = tf.cast(input_image, tf.float32) + real_image = tf.cast(real_image, tf.float32) + + return input_image, real_image + + +def resize(input_image, real_image, height, width): + input_image = tf.image.resize(input_image, [height, width], + method=tf.image.ResizeMethod.NEAREST_NEIGHBOR) + real_image = tf.image.resize(real_image, [height, width], + method=tf.image.ResizeMethod.NEAREST_NEIGHBOR) + + return input_image, real_image + + +def random_crop(input_image, real_image): + stacked_image = tf.stack([input_image, real_image], axis=0) + cropped_image = tf.image.random_crop( + stacked_image, size=[2, IMG_HEIGHT, IMG_WIDTH, 3]) + + return cropped_image[0], cropped_image[1] + + +def normalize(input_image, real_image): + input_image = (input_image / 127.5) - 1 + real_image = (real_image / 127.5) - 1 + + return input_image, real_image + + +@tf.function +def random_jitter(input_image, real_image): + """Random jittering. + + Resizes to 286 x 286 and then randomly crops to IMG_HEIGHT x IMG_WIDTH. + + Args: + input_image: Input Image + real_image: Real Image + + Returns: + Input Image, real image + """ + # resizing to 286 x 286 x 3 + input_image, real_image = resize(input_image, real_image, 286, 286) + + # randomly cropping to 256 x 256 x 3 + input_image, real_image = random_crop(input_image, real_image) + + if tf.random.uniform(()) > 0.5: + # random mirroring + input_image = tf.image.flip_left_right(input_image) + real_image = tf.image.flip_left_right(real_image) + + return input_image, real_image + + +def load_image_train(image_file): + input_image, real_image = load(image_file) + input_image, real_image = random_jitter(input_image, real_image) + input_image, real_image = normalize(input_image, real_image) + + return input_image, real_image + + +def load_image_test(image_file): + input_image, real_image = load(image_file) + input_image, real_image = resize(input_image, real_image, + IMG_HEIGHT, IMG_WIDTH) + input_image, real_image = normalize(input_image, real_image) + + return input_image, real_image + + +def create_dataset(path_to_train_images, path_to_test_images, buffer_size, + batch_size): + """Creates a tf.data Dataset. + + Args: + path_to_train_images: Path to train images folder. + path_to_test_images: Path to test images folder. + buffer_size: Shuffle buffer size. + batch_size: Batch size + + Returns: + train dataset, test dataset + """ + train_dataset = tf.data.Dataset.list_files(path_to_train_images) + train_dataset = train_dataset.shuffle(buffer_size) + train_dataset = train_dataset.map( + load_image_train, num_parallel_calls=AUTOTUNE) + train_dataset = train_dataset.batch(batch_size) + + test_dataset = tf.data.Dataset.list_files(path_to_test_images) + test_dataset = test_dataset.map( + load_image_test, num_parallel_calls=AUTOTUNE) + test_dataset = test_dataset.batch(batch_size) + + return train_dataset, test_dataset + + +class InstanceNormalization(tf.keras.layers.Layer): + """Instance Normalization Layer (https://arxiv.org/abs/1607.08022).""" + + def __init__(self, epsilon=1e-5): + super(InstanceNormalization, self).__init__() + self.epsilon = epsilon + + def build(self, input_shape): + self.scale = self.add_weight( + name='scale', + shape=input_shape[-1:], + initializer=tf.random_normal_initializer(1., 0.02), + trainable=True) + + self.offset = self.add_weight( + name='offset', + shape=input_shape[-1:], + initializer='zeros', + trainable=True) + + def call(self, x): + mean, variance = tf.nn.moments(x, axes=[1, 2], keepdims=True) + inv = tf.math.rsqrt(variance + self.epsilon) + normalized = (x - mean) * inv + return self.scale * normalized + self.offset + + +def downsample(filters, size, norm_type='batchnorm', apply_norm=True): + """Downsamples an input. + + Conv2D => Batchnorm => LeakyRelu + + Args: + filters: number of filters + size: filter size + norm_type: Normalization type; either 'batchnorm' or 'instancenorm'. + apply_norm: If True, adds the batchnorm layer + + Returns: + Downsample Sequential Model + """ + initializer = tf.random_normal_initializer(0., 0.02) + + result = tf.keras.Sequential() + result.add( + tf.keras.layers.Conv2D(filters, size, strides=2, padding='same', + kernel_initializer=initializer, use_bias=False)) + + if apply_norm: + if norm_type.lower() == 'batchnorm': + result.add(tf.keras.layers.BatchNormalization()) + elif norm_type.lower() == 'instancenorm': + result.add(InstanceNormalization()) + + result.add(tf.keras.layers.LeakyReLU()) + + return result + + +def upsample(filters, size, norm_type='batchnorm', apply_dropout=False): + """Upsamples an input. + + Conv2DTranspose => Batchnorm => Dropout => Relu + + Args: + filters: number of filters + size: filter size + norm_type: Normalization type; either 'batchnorm' or 'instancenorm'. + apply_dropout: If True, adds the dropout layer + + Returns: + Upsample Sequential Model + """ + + initializer = tf.random_normal_initializer(0., 0.02) + + result = tf.keras.Sequential() + result.add( + tf.keras.layers.Conv2DTranspose(filters, size, strides=2, + padding='same', + kernel_initializer=initializer, + use_bias=False)) + + if norm_type.lower() == 'batchnorm': + result.add(tf.keras.layers.BatchNormalization()) + elif norm_type.lower() == 'instancenorm': + result.add(InstanceNormalization()) + + if apply_dropout: + result.add(tf.keras.layers.Dropout(0.5)) + + result.add(tf.keras.layers.ReLU()) + + return result + + +def unet_generator(output_channels, norm_type='batchnorm'): + """Modified u-net generator model (https://arxiv.org/abs/1611.07004). + + Args: + output_channels: Output channels + norm_type: Type of normalization. Either 'batchnorm' or 'instancenorm'. + + Returns: + Generator model + """ + + down_stack = [ + downsample(64, 4, norm_type, apply_norm=False), # (bs, 128, 128, 64) + downsample(128, 4, norm_type), # (bs, 64, 64, 128) + downsample(256, 4, norm_type), # (bs, 32, 32, 256) + downsample(512, 4, norm_type), # (bs, 16, 16, 512) + downsample(512, 4, norm_type), # (bs, 8, 8, 512) + downsample(512, 4, norm_type), # (bs, 4, 4, 512) + downsample(512, 4, norm_type), # (bs, 2, 2, 512) + downsample(512, 4, norm_type), # (bs, 1, 1, 512) + ] + + up_stack = [ + upsample(512, 4, norm_type, apply_dropout=True), # (bs, 2, 2, 1024) + upsample(512, 4, norm_type, apply_dropout=True), # (bs, 4, 4, 1024) + upsample(512, 4, norm_type, apply_dropout=True), # (bs, 8, 8, 1024) + upsample(512, 4, norm_type), # (bs, 16, 16, 1024) + upsample(256, 4, norm_type), # (bs, 32, 32, 512) + upsample(128, 4, norm_type), # (bs, 64, 64, 256) + upsample(64, 4, norm_type), # (bs, 128, 128, 128) + ] + + initializer = tf.random_normal_initializer(0., 0.02) + last = tf.keras.layers.Conv2DTranspose( + output_channels, 4, strides=2, + padding='same', kernel_initializer=initializer, + activation='tanh') # (bs, 256, 256, 3) + + concat = tf.keras.layers.Concatenate() + + inputs = tf.keras.layers.Input(shape=[None, None, 3]) + x = inputs + + # Downsampling through the model + skips = [] + for down in down_stack: + x = down(x) + skips.append(x) + + skips = reversed(skips[:-1]) + + # Upsampling and establishing the skip connections + for up, skip in zip(up_stack, skips): + x = up(x) + x = concat([x, skip]) + + x = last(x) + + return tf.keras.Model(inputs=inputs, outputs=x) + + +def discriminator(norm_type='batchnorm', target=True): + """PatchGan discriminator model (https://arxiv.org/abs/1611.07004). + + Args: + norm_type: Type of normalization. Either 'batchnorm' or 'instancenorm'. + target: Bool, indicating whether target image is an input or not. + + Returns: + Discriminator model + """ + + initializer = tf.random_normal_initializer(0., 0.02) + + inp = tf.keras.layers.Input(shape=[None, None, 3], name='input_image') + x = inp + + if target: + tar = tf.keras.layers.Input(shape=[None, None, 3], name='target_image') + x = tf.keras.layers.concatenate([inp, tar]) # (bs, 256, 256, channels*2) + + down1 = downsample(64, 4, norm_type, False)(x) # (bs, 128, 128, 64) + down2 = downsample(128, 4, norm_type)(down1) # (bs, 64, 64, 128) + down3 = downsample(256, 4, norm_type)(down2) # (bs, 32, 32, 256) + + zero_pad1 = tf.keras.layers.ZeroPadding2D()(down3) # (bs, 34, 34, 256) + conv = tf.keras.layers.Conv2D( + 512, 4, strides=1, kernel_initializer=initializer, + use_bias=False)(zero_pad1) # (bs, 31, 31, 512) + + if norm_type.lower() == 'batchnorm': + norm1 = tf.keras.layers.BatchNormalization()(conv) + elif norm_type.lower() == 'instancenorm': + norm1 = InstanceNormalization()(conv) + + leaky_relu = tf.keras.layers.LeakyReLU()(norm1) + + zero_pad2 = tf.keras.layers.ZeroPadding2D()(leaky_relu) # (bs, 33, 33, 512) + + last = tf.keras.layers.Conv2D( + 1, 4, strides=1, + kernel_initializer=initializer)(zero_pad2) # (bs, 30, 30, 1) + + if target: + return tf.keras.Model(inputs=[inp, tar], outputs=last) + else: + return tf.keras.Model(inputs=inp, outputs=last) + + +def get_checkpoint_prefix(): + checkpoint_dir = './training_checkpoints' + checkpoint_prefix = os.path.join(checkpoint_dir, 'ckpt') + + return checkpoint_prefix + + +class Pix2pix(object): + """Pix2pix class. + + Args: + epochs: Number of epochs. + enable_function: If true, train step is decorated with tf.function. + buffer_size: Shuffle buffer size.. + batch_size: Batch size. + """ + + def __init__(self, epochs, enable_function): + self.epochs = epochs + self.enable_function = enable_function + self.lambda_value = 100 + self.loss_object = tf.keras.losses.BinaryCrossentropy(from_logits=True) + self.generator_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5) + self.discriminator_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5) + self.generator = unet_generator(output_channels=3) + self.discriminator = discriminator() + self.checkpoint = tf.train.Checkpoint( + generator_optimizer=self.generator_optimizer, + discriminator_optimizer=self.discriminator_optimizer, + generator=self.generator, + discriminator=self.discriminator) + + def discriminator_loss(self, disc_real_output, disc_generated_output): + real_loss = self.loss_object( + tf.ones_like(disc_real_output), disc_real_output) + + generated_loss = self.loss_object(tf.zeros_like( + disc_generated_output), disc_generated_output) + + total_disc_loss = real_loss + generated_loss + + return total_disc_loss + + def generator_loss(self, disc_generated_output, gen_output, target): + gan_loss = self.loss_object(tf.ones_like( + disc_generated_output), disc_generated_output) + + # mean absolute error + l1_loss = tf.reduce_mean(tf.abs(target - gen_output)) + total_gen_loss = gan_loss + (self.lambda_value * l1_loss) + return total_gen_loss + + def train_step(self, input_image, target_image): + """One train step over the generator and discriminator model. + + Args: + input_image: Input Image. + target_image: Target image. + + Returns: + generator loss, discriminator loss. + """ + with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape: + gen_output = self.generator(input_image, training=True) + + disc_real_output = self.discriminator( + [input_image, target_image], training=True) + disc_generated_output = self.discriminator( + [input_image, gen_output], training=True) + + gen_loss = self.generator_loss( + disc_generated_output, gen_output, target_image) + disc_loss = self.discriminator_loss( + disc_real_output, disc_generated_output) + + generator_gradients = gen_tape.gradient( + gen_loss, self.generator.trainable_variables) + discriminator_gradients = disc_tape.gradient( + disc_loss, self.discriminator.trainable_variables) + + self.generator_optimizer.apply_gradients(zip( + generator_gradients, self.generator.trainable_variables)) + self.discriminator_optimizer.apply_gradients(zip( + discriminator_gradients, self.discriminator.trainable_variables)) + + return gen_loss, disc_loss + + def train(self, dataset, checkpoint_pr): + """Train the GAN for x number of epochs. + + Args: + dataset: train dataset. + checkpoint_pr: prefix in which the checkpoints are stored. + + Returns: + Time for each epoch. + """ + time_list = [] + if self.enable_function: + self.train_step = tf.function(self.train_step) + + for epoch in range(self.epochs): + start_time = time.time() + for input_image, target_image in dataset: + gen_loss, disc_loss = self.train_step(input_image, target_image) + + wall_time_sec = time.time() - start_time + time_list.append(wall_time_sec) + + # saving (checkpoint) the model every 20 epochs + if (epoch + 1) % 20 == 0: + self.checkpoint.save(file_prefix=checkpoint_pr) + + template = 'Epoch {}, Generator loss {}, Discriminator Loss {}' + print (template.format(epoch, gen_loss, disc_loss)) + + return time_list + + +def run_main(argv): + del argv + kwargs = {'epochs': FLAGS.epochs, 'enable_function': FLAGS.enable_function, + 'path': FLAGS.path, 'buffer_size': FLAGS.buffer_size, + 'batch_size': FLAGS.batch_size} + main(**kwargs) + + +def main(epochs, enable_function, path, buffer_size, batch_size): + path_to_folder = path + + pix2pix_object = Pix2pix(epochs, enable_function) + + train_dataset, _ = create_dataset( + os.path.join(path_to_folder, 'train/*.jpg'), + os.path.join(path_to_folder, 'test/*.jpg'), + buffer_size, batch_size) + checkpoint_pr = get_checkpoint_prefix() + print ('Training ...') + return pix2pix_object.train(train_dataset, checkpoint_pr) + + +if __name__ == '__main__': + app.run(run_main) \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 918635b..18991ed 100644 Binary files a/requirements.txt and b/requirements.txt differ