DenseNet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "45579bb5",
   "metadata": {},
   "source": [
    "### oxford_flowers102 dataseti"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "95bf6df4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6e184c39",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_name = 'oxford_flowers102'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e3f8eef",
   "metadata": {},
   "source": [
    "#### Tensorflow datasetlaridan uc_merged datasetini yuklab olamiz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c7263fdc",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow_datasets as tfds\n",
    "\n",
    "(train,test,validation), info = tfds.load(\n",
    "    data_name,\n",
    "    split=['test','train','validation'],\n",
    "    data_dir=\"dataset\\\\\",\n",
    "    shuffle_files=True,\n",
    "    as_supervised=True,\n",
    "    with_info=True,\n",
    "    batch_size=-1\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3c059814",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tfds.core.DatasetInfo(\n",
       "    name='oxford_flowers102',\n",
       "    full_name='oxford_flowers102/2.1.1',\n",
       "    description=\"\"\"\n",
       "    The Oxford Flowers 102 dataset is a consistent of 102 flower categories commonly\n",
       "    occurring in the United Kingdom. Each class consists of between 40 and 258\n",
       "    images. The images have large scale, pose and light variations. In addition,\n",
       "    there are categories that have large variations within the category and several\n",
       "    very similar categories.\n",
       "    \n",
       "    The dataset is divided into a training set, a validation set and a test set. The\n",
       "    training set and validation set each consist of 10 images per class (totalling\n",
       "    1020 images each). The test set consists of the remaining 6149 images (minimum\n",
       "    20 per class).\n",
       "    \n",
       "    Note: The dataset by default comes with a test size larger than the train size.\n",
       "    For more info see this\n",
       "    [issue](https://github.com/tensorflow/datasets/issues/3022).\n",
       "    \"\"\",\n",
       "    homepage='https://www.robots.ox.ac.uk/~vgg/data/flowers/102/',\n",
       "    data_path='dataset\\\\oxford_flowers102\\\\2.1.1',\n",
       "    file_format=tfrecord,\n",
       "    download_size=328.90 MiB,\n",
       "    dataset_size=331.34 MiB,\n",
       "    features=FeaturesDict({\n",
       "        'file_name': Text(shape=(), dtype=string),\n",
       "        'image': Image(shape=(None, None, 3), dtype=uint8),\n",
       "        'label': ClassLabel(shape=(), dtype=int64, num_classes=102),\n",
       "    }),\n",
       "    supervised_keys=('image', 'label'),\n",
       "    disable_shuffling=False,\n",
       "    splits={\n",
       "        'test': <SplitInfo num_examples=6149, num_shards=2>,\n",
       "        'train': <SplitInfo num_examples=1020, num_shards=1>,\n",
       "        'validation': <SplitInfo num_examples=1020, num_shards=1>,\n",
       "    },\n",
       "    citation=\"\"\"@InProceedings{Nilsback08,\n",
       "       author = \"Nilsback, M-E. and Zisserman, A.\",\n",
       "       title = \"Automated Flower Classification over a Large Number of Classes\",\n",
       "       booktitle = \"Proceedings of the Indian Conference on Computer Vision, Graphics and Image Processing\",\n",
       "       year = \"2008\",\n",
       "       month = \"Dec\"\n",
       "    }\"\"\",\n",
       ")"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "info"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a630cf43",
   "metadata": {},
   "source": [
    "#### Image va labellarni preprocessingdan o'tkazamiz "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7871de3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_images,train_labels = tfds.as_numpy(train)\n",
    "test_images,test_labels = tfds.as_numpy(test)\n",
    "validation_images,validation_labels = tfds.as_numpy(validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "183e6662",
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "\n",
    "def preprocessing(images,label):\n",
    "    images_ = []\n",
    "    \n",
    "    for i in range(len(images)):\n",
    "        image = cv2.cvtColor(images[i], cv2.COLOR_BGR2RGB)\n",
    "        image = cv2.resize(image,(224,224),interpolation = cv2.INTER_AREA)\n",
    "        image = image/127.5-1.0\n",
    "        image = image.astype('float16')\n",
    "        \n",
    "        images_.append(image)\n",
    "        \n",
    "    label = label.astype('uint16')\n",
    "    images = np.array(images_)\n",
    "    return images,label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "46f2295e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train images shape:(6149, 224, 224, 3)\n",
      "Train labels shape:(6149,)\n"
     ]
    }
   ],
   "source": [
    "train_images,train_labels = preprocessing(train_images,train_labels)\n",
    "print(f\"Train images shape:{train_images.shape}\\nTrain labels shape:{train_labels.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5f89c89e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test images shape:(1020, 224, 224, 3)\n",
      "Test labels shape:(1020,)\n"
     ]
    }
   ],
   "source": [
    "test_images,test_labels = preprocessing(test_images,test_labels)\n",
    "print(f\"Test images shape:{test_images.shape}\\nTest labels shape:{test_labels.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e126a130",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation images shape:(1020, 224, 224, 3)\n",
      "Validation labels shape:(1020,)\n"
     ]
    }
   ],
   "source": [
    "validation_images,validation_labels = preprocessing(validation_images,validation_labels)\n",
    "print(f\"Validation images shape:{validation_images.shape}\\nValidation labels shape:{validation_labels.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a8fc1fbd",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_ds = tf.data.Dataset.from_tensor_slices((train_images,train_labels)).batch(32)\n",
    "\n",
    "test_ds = tf.data.Dataset.from_tensor_slices((test_images,test_labels)).batch(32)\n",
    "\n",
    "validation_ds = tf.data.Dataset.from_tensor_slices((validation_images,validation_labels)).batch(32)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e461e8b5",
   "metadata": {},
   "source": [
    "### Model o'qitish uchun DenseNet arxitekturasidan foydalanamiz\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "51d21f16",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Model\n",
    "import tensorflow.keras.backend as K"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "3bad5b09",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DenseNet121(Model):\n",
    "    def __init__(self, InputShape, Filters=32):\n",
    "        super(DenseNet121, self).__init__()\n",
    "        \n",
    "        self.InputShape = InputShape\n",
    "        self.Filters = Filters\n",
    "\n",
    "        def Convolution_Block(x, Filters, kernel=1, strides=1):\n",
    "            x = tf.keras.layers.BatchNormalization()(x)\n",
    "            x = tf.keras.layers.ReLU()(x)\n",
    "            x = tf.keras.layers.Conv2D(Filters, kernel, strides=strides, padding='same')(x)\n",
    "            return x\n",
    "\n",
    "        def Dense_Block(x, repetition):\n",
    "            for _ in range(repetition):\n",
    "                y = Convolution_Block(x, 4 * Filters)\n",
    "                y = Convolution_Block(y, Filters, 3)\n",
    "                x = tf.keras.layers.Concatenate()([y, x])\n",
    "            return x\n",
    "\n",
    "        def Transition_Layer(x):\n",
    "            x = Convolution_Block(x, K.int_shape(x)[-1] // 2)\n",
    "            x = tf.keras.layers.AvgPool2D(2, strides=2, padding='same')(x)\n",
    "            return x\n",
    "\n",
    "        inputs = tf.keras.layers.Input(InputShape)\n",
    "        x = tf.keras.layers.Conv2D(64, 7, strides=2, padding='same')(inputs)\n",
    "        x = tf.keras.layers.MaxPool2D(3, strides=2, padding='same')(x)\n",
    "\n",
    "        for repetition in [6, 12, 24, 16]:\n",
    "            d = Dense_Block(x, repetition)\n",
    "            x = Transition_Layer(d)\n",
    "\n",
    "        x = tf.keras.layers.GlobalAveragePooling2D()(d)\n",
    "        output = tf.keras.layers.Dense(102, activation='softmax')(x)\n",
    "\n",
    "        self.model = Model(inputs, output)\n",
    "\n",
    "    def call(self, inputs):\n",
    "        return self.model(inputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "885840c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs_shape = 224, 224, 3\n",
    "model = DenseNet121(inputs_shape)\n",
    "\n",
    "inputs_tensor = tf.keras.layers.Input(inputs_shape)\n",
    "output_tensor = model(inputs_tensor)\n",
    "\n",
    "model = Model(inputs=inputs_tensor, outputs=output_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ef74e761",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_object = tf.keras.losses.SparseCategoricalCrossentropy()\n",
    "\n",
    "optimizer = tf.keras.optimizers.Adam()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "cc78cc64",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loss = tf.keras.metrics.Mean(name='train_loss')\n",
    "train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')\n",
    "\n",
    "test_loss = tf.keras.metrics.Mean(name='test_loss')\n",
    "test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ad87e757",
   "metadata": {},
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def train_step(images, labels):\n",
    "    with tf.GradientTape() as tape:\n",
    "\n",
    "        predictions = model(images, training=True)\n",
    "        loss = loss_object(labels, predictions)\n",
    "        \n",
    "    gradients = tape.gradient(loss, model.trainable_variables)\n",
    "    optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n",
    "\n",
    "    train_loss(loss)\n",
    "    train_accuracy(labels, predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "215633a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def test_step(images, labels):\n",
    "    \n",
    "    predictions = model(images, training=False)\n",
    "    t_loss = loss_object(labels, predictions)\n",
    "\n",
    "    test_loss(t_loss)\n",
    "    test_accuracy(labels, predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "05fe39ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "** 1-epoch:\n",
      "loss: 3.9972922801971436\tsparse_categorical_accuracy: 0.11140022426843643\n",
      "val_loss: 9.916070938110352\tval_sparse_categorical_accuracy:0.01274509821087122\n",
      "** 2-epoch:\n",
      "loss: 3.271921157836914\tsparse_categorical_accuracy: 0.2008456587791443\n",
      "val_loss: 4.767903804779053\tval_sparse_categorical_accuracy:0.09509804099798203\n",
      "** 3-epoch:\n",
      "loss: 2.897749423980713\tsparse_categorical_accuracy: 0.2603675425052643\n",
      "val_loss: 4.941200256347656\tval_sparse_categorical_accuracy:0.10784313827753067\n",
      "** 4-epoch:\n",
      "loss: 2.5932817459106445\tsparse_categorical_accuracy: 0.319076269865036\n",
      "val_loss: 5.119296550750732\tval_sparse_categorical_accuracy:0.14803922176361084\n",
      "** 5-epoch:\n",
      "loss: 2.32743763923645\tsparse_categorical_accuracy: 0.37664660811424255\n",
      "val_loss: 4.752178192138672\tval_sparse_categorical_accuracy:0.15294118225574493\n"
     ]
    }
   ],
   "source": [
    "EPOCHS = 5\n",
    "\n",
    "loss,val_loss = [],[]\n",
    "accuracy, val_accuracy = [],[]\n",
    "\n",
    "for epoch in range(EPOCHS):\n",
    "\n",
    "    train_loss.reset_states()\n",
    "    train_accuracy.reset_states()\n",
    "    \n",
    "    test_loss.reset_states()\n",
    "    test_accuracy.reset_states()\n",
    "\n",
    "    for images, labels in train_ds:\n",
    "        train_step(images, labels)\n",
    "\n",
    "    for val_images, val_labels in validation_ds:\n",
    "        test_step(val_images, val_labels)\n",
    "    \n",
    "    loss.append(train_loss.result())\n",
    "    accuracy.append(train_accuracy.result())\n",
    "    \n",
    "    val_loss.append(test_loss.result())\n",
    "    val_accuracy.append(test_accuracy.result())\n",
    "    \n",
    "    print(f\"** {epoch + 1}-epoch:\\nloss: {train_loss.result()}\\tsparse_categorical_accuracy: {train_accuracy.result()}\\nval_loss: {test_loss.result()}\\tval_sparse_categorical_accuracy:{test_accuracy.result()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "800c7903",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test_loss: 4.85431432723999\n",
      "test_accuracy: 0.15490196645259857\n"
     ]
    }
   ],
   "source": [
    "for test_images,test_labels in test_ds:\n",
    "    test_step(test_images, test_labels)\n",
    "    \n",
    "print(f\"test_loss: {test_loss.result()}\\ntest_accuracy: {test_accuracy.result()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "aa866f76",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "epochs = [i for i in range(EPOCHS)]\n",
    "\n",
    "plt.plot(epochs, loss, label='loss')\n",
    "plt.plot(epochs, val_loss, label='val_loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "66e728c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(epochs, accuracy, label='accuracy')\n",
    "plt.plot(epochs, val_accuracy, label='val_accuracy')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "3a9c2067",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_1\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_2 (InputLayer)        [(None, 224, 224, 3)]     0         \n",
      "                                                                 \n",
      " dense_net121 (DenseNet121)  (None, 102)               7147942   \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 7,147,942\n",
      "Trainable params: 7,066,470\n",
      "Non-trainable params: 81,472\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "ceaed1af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n",
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 120). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: models/DenseNet/model\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: models/DenseNet/model\\assets\n"
     ]
    }
   ],
   "source": [
    "model.save('models/DenseNet/model')"
   ]
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}