keras_flower_classification_real_dataset.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['daisy', 'dandelion', 'rose', 'sunflower', 'tulip']\n",
      "Types of flowers found:  5\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "import pandas as pd \n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "\n",
    "flowers_path = os.listdir('flowers-recognition/flowers')\n",
    "\n",
    "flower_types = os.listdir('flowers-recognition/flowers')\n",
    "print (flower_types)  #what kinds of flowers are in this dataset\n",
    "\n",
    "print(\"Types of flowers found: \", len(flowers_path))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "path = 'flowers-recognition/flowers/'\n",
    "\n",
    "\n",
    "im_size = 60\n",
    "\n",
    "images = []\n",
    "labels = []\n",
    "\n",
    "for i in flower_types:\n",
    "    data_path = path + str(i)  # entered in daisy folder\n",
    "    filenames = [i for i in os.listdir(data_path) if i.endswith('.jpg')]\n",
    "    #print(filenames)  # will get the names of all images which ends with .jpg extension\n",
    "    for f in filenames:\n",
    "        img = cv2.imread(data_path + '/' + f)  # reading that image as array\n",
    "        #print(img)  # will get the image as an array\n",
    "        img = cv2.resize(img, (im_size, im_size))\n",
    "        images.append(img)\n",
    "        labels.append(i)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8646, 60, 60, 3)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Transform the image array to a numpy type\n",
    "\n",
    "images = np.array(images)\n",
    "\n",
    "images.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "images = images.astype('float32') / 255.0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, ..., 4, 4, 4], dtype=int64)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extract the labels\n",
    "\n",
    "label_dummies = pd.get_dummies(labels)\n",
    "\n",
    "labels =  label_dummies.values.argmax(1)\n",
    "labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4], dtype=int64)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.unique(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# Convert the shuffled list to numpy array type\n",
    "\n",
    "images = np.array(images)\n",
    "labels = np.array(labels)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(images, labels, test_size = 0.2, random_state = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n",
      "c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:516: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:517: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:518: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:519: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:520: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
      "c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:541: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:542: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:543: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:544: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:545: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:550: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    }
   ],
   "source": [
    "# Develop a sequential model using tensorflow keras\n",
    "import keras\n",
    "import tensorflow as tf\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout, Flatten\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:66: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n",
      "\n",
      "WARNING:tensorflow:From c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:541: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n",
      "\n",
      "WARNING:tensorflow:From c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:4432: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "model =Sequential()\n",
    "model.add(Flatten( input_shape=(60,60,3)))\n",
    "model.add(Dense(128, activation='relu'))\n",
    "model.add(Dense(5, activation='softmax'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "flatten_1 (Flatten)          (None, 10800)             0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 128)               1382528   \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 5)                 645       \n",
      "=================================================================\n",
      "Total params: 1,383,173\n",
      "Trainable params: 1,383,173\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from keras.utils.vis_utils import plot_model\n",
    "plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\keras\\optimizers.py:793: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n",
      "\n",
      "WARNING:tensorflow:From c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3622: The name tf.log is deprecated. Please use tf.math.log instead.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Compute the model parameters\n",
    "\n",
    "model.compile(optimizer=tf.train.AdamOptimizer(), \n",
    "              loss='sparse_categorical_crossentropy',\n",
    "              metrics=['accuracy'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorflow\\python\\ops\\math_grad.py:1250: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
      "WARNING:tensorflow:From c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:1033: The name tf.assign_add is deprecated. Please use tf.compat.v1.assign_add instead.\n",
      "\n",
      "Train on 6916 samples, validate on 1730 samples\n",
      "Epoch 1/10\n",
      "6916/6916 [==============================] - 2s 277us/step - loss: 2.5512 - acc: 0.2597 - val_loss: 1.5463 - val_acc: 0.2382\n",
      "Epoch 2/10\n",
      "6916/6916 [==============================] - 2s 220us/step - loss: 1.5190 - acc: 0.2714 - val_loss: 1.5237 - val_acc: 0.3341\n",
      "Epoch 3/10\n",
      "6916/6916 [==============================] - 2s 239us/step - loss: 1.4664 - acc: 0.3250 - val_loss: 1.4438 - val_acc: 0.3277\n",
      "Epoch 4/10\n",
      "6916/6916 [==============================] - 2s 246us/step - loss: 1.4215 - acc: 0.3489 - val_loss: 1.4108 - val_acc: 0.3491\n",
      "Epoch 5/10\n",
      "6916/6916 [==============================] - 2s 254us/step - loss: 1.3168 - acc: 0.4237 - val_loss: 1.2940 - val_acc: 0.4445\n",
      "Epoch 6/10\n",
      "6916/6916 [==============================] - 2s 254us/step - loss: 1.2884 - acc: 0.4588 - val_loss: 1.2621 - val_acc: 0.4659\n",
      "Epoch 7/10\n",
      "6916/6916 [==============================] - 2s 253us/step - loss: 1.2528 - acc: 0.4676 - val_loss: 1.2879 - val_acc: 0.4543\n",
      "Epoch 8/10\n",
      "6916/6916 [==============================] - 2s 250us/step - loss: 1.2385 - acc: 0.4727 - val_loss: 1.2966 - val_acc: 0.4318\n",
      "Epoch 9/10\n",
      "6916/6916 [==============================] - 2s 255us/step - loss: 1.2284 - acc: 0.4754 - val_loss: 1.2456 - val_acc: 0.4711\n",
      "Epoch 10/10\n",
      "6916/6916 [==============================] - 2s 264us/step - loss: 1.2073 - acc: 0.4880 - val_loss: 1.2284 - val_acc: 0.4832\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x27f15c5b128>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Train the model  with 5 epochs \n",
    "\n",
    "#model.fit(X_train,y_train, epochs=5)\n",
    "model.fit(X_train, y_train, batch_size = 32, epochs = 10,validation_data = (X_test,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 3, 1, ..., 1, 1, 4], dtype=int64)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred = model.predict_classes(X_test)\n",
    "y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=60x60 at 0x27F15EE8198>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "\n",
    "test = Image.open(\"test1.jpg\")\n",
    "test\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0., 0.]], dtype=float32)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred=model.predict(np.expand_dims(test, axis=0))\n",
    "y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "#model.evaluate(): To calculate the loss values for input data.\n",
    "#model.predict(): To generate network output for input data.\n",
    "#model.predict_classes(): To generate class outputs for input data.\n",
    "#model.predict_proba(): To generate class probabilities for input data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 1.2283754933087123\n",
      "Test accuracy: 0.48323699421965316\n"
     ]
    }
   ],
   "source": [
    "score = model.evaluate(X_test, y_test, verbose=0)\n",
    "print('Test loss:', score[0])\n",
    "print('Test accuracy:', score[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\keras\\engine\\saving.py:135: UserWarning: TensorFlow optimizers do not make it possible to access optimizer attributes or optimizer state after instantiation. As a result, we cannot save the optimizer as part of the model save file.You will have to compile your model again after loading it. Prefer using a Keras optimizer instead (see keras.io/optimizers).\n",
      "  'TensorFlow optimizers do not '\n"
     ]
    }
   ],
   "source": [
    "mp = \"flower_model.h5\"   # pip install h5py\n",
    "model.save(mp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\aarohi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\keras\\engine\\saving.py:310: UserWarning: No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "  warnings.warn('No training configuration found in save file: '\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0., 0.]], dtype=float32)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from keras.models import load_model\n",
    "model = load_model('flower_model.h5')\n",
    "predicted = model.predict(np.expand_dims(test, axis=0))\n",
    "predicted"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}