deepWeed_agave.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "deepWeed_agave.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyOz2MJesgXSmuYYVeOtz0UD",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/vagi8/deepWeed/blob/main/deepWeed_agave.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NiacI6DMDleF"
      },
      "source": [
        "import pickle\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.model_selection import train_test_split"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0PTvGSLU7cdO",
        "outputId": "4937ca14-209a-4fc1-b47b-a644f7f02784"
      },
      "source": [
        "path=''"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive/; to attempt to forcibly remount, call drive.mount(\"/content/drive/\", force_remount=True).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9B-01oOfj2mZ"
      },
      "source": [
        "import matplotlib\n",
        "from matplotlib.colors import ListedColormap\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "sns.set()\n",
        "import cv2\n",
        "import random\n",
        "from datetime import datetime\n",
        "from glob import glob\n",
        "from os import listdir\n",
        "import pickle\n",
        "from skimage import io"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6a5nVmqJJMII"
      },
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "import keras.backend as K\n",
        "from keras.utils.np_utils import to_categorical\n",
        "from keras.models import Sequential,model_from_json\n",
        "from keras.layers import Dense, Dropout, Flatten\n",
        "from tensorflow.keras.metrics import BinaryAccuracy, Precision,Recall,AUC\n",
        "from tensorflow.keras.callbacks import ReduceLROnPlateau, ModelCheckpoint, EarlyStopping\n",
        "from tensorflow.keras.applications import VGG16,ResNet50"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_aLk2TrF7aP8"
      },
      "source": [
        "with open(path+'weed_train_array.pkl', 'rb') as input:\n",
        "    data = pickle.load(input)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Uoo8-mj68MQ3",
        "outputId": "f359f717-7b9d-4fb0-de32-e3476c3dbfd4"
      },
      "source": [
        "combined_data=np.array(data)\n",
        "X = []\n",
        "y = []\n",
        "specices=[]\n",
        "for features,label,specice in combined_data:\n",
        "    X.append(features)\n",
        "    y.append(label)\n",
        "    if specice not in specices:\n",
        "      specices.append(specice)\n",
        "\n",
        "# reshape X data to make valid 4D data with numpy\n",
        "X = np.array(X).reshape(-1, 64, 64, 3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:1: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n",
            "  \"\"\"Entry point for launching an IPython kernel.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yQKJEc7B9lN6"
      },
      "source": [
        "#creating a Map for labels\n",
        "\n",
        "unique_label=set(y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_7LPzh2dDe6S"
      },
      "source": [
        "# dog_breed=['great_pyrenees','kuvasz','american_staffordshire_terrier','welsh_springer_spaniel','curly-coated_retriever','irish_water_spaniel','brittany_spaniel','miniature_pinscher','siberian_husky','silky_terrier','soft-coated_wheaten_terrier','staffordshire_bullterrier','standard_poodle','standard_schnauzer','sussex_spaniel','tibetan_mastiff','tibetan_terrier','toy_poodle','scottish_deerhound','maltese_dog']\n",
        "# len(dog_breed)\n",
        "# images=[]\n",
        "# for i in dog_breed:\n",
        "#   images.append(X[y.index(i)])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Got5A3THDJfn"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from PIL.Image import Image as PilImage\n",
        "import textwrap, os\n",
        "\n",
        "def display_images(\n",
        "    images: [PilImage], labels,\n",
        "    columns=5, width=20, height=8, max_images=15, \n",
        "    label_wrap_length=50, label_font_size=8):\n",
        "\n",
        "    if not images:\n",
        "        print(\"No images to display.\")\n",
        "        return \n",
        "\n",
        "    # if len(images) > max_images:\n",
        "    #     print(f\"Showing {max_images} images of {len(images)}:\")\n",
        "    #     images=images[0:max_images]\n",
        "\n",
        "    height = max(height, int(len(images)/columns) * height)\n",
        "    plt.figure(figsize=(width, height))\n",
        "    for i, image in enumerate(images):\n",
        "\n",
        "        plt.subplot(int(len(images) / columns + 1), columns, i + 1)\n",
        "        plt.imshow(image)\n",
        "        plt.title(labels[i])\n",
        "        # if hasattr(image, 'filename'):\n",
        "        #     title=image.filename\n",
        "        #     if title.endswith(\"/\"): title = title[0:-1]\n",
        "        #     title=os.path.basename(title)\n",
        "        #     title=textwrap.wrap(title, label_wrap_length)\n",
        "        #     title=\"\\n\".join(title)\n",
        "        #     plt.title(title, fontsize=label_font_size); "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NBv_-Gt-DYsG"
      },
      "source": [
        "# display_images(images,dog_breed)\n",
        "# img = X[y.index(118)]\n",
        "# display_images([img],['boston_bull'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "crNeFMAPOQsw"
      },
      "source": [
        "# unique_label=list(unique_label)\n",
        "# for i in range(len(y)):\n",
        "#   y[i]=unique_label.index(y[i])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4WVuczpt8XBp"
      },
      "source": [
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42)\n",
        "X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.30, random_state=42)\n",
        "y_train = to_categorical(y_train)\n",
        "y_val = to_categorical(y_val)\n",
        "y_test = to_categorical(y_test)\n",
        "print(X_train.shape, X_test.shape, y_train.shape, y_test.shape,X_val.shape,y_val.shape)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sWXdWTc9kLkb"
      },
      "source": [
        "#loading vgg16 as base model \n",
        "base_model = VGG16(input_shape=(64,64,3),include_top=False,weights=\"imagenet\")\n",
        "\n",
        "# Freezing base model Layers \n",
        "for layer in base_model.layers:\n",
        "    layer.trainable=False\n",
        "    \n",
        "# Building our custom model layers on top of base model \n",
        "model=Sequential()\n",
        "model.add(base_model)\n",
        "model.add(Dropout(0.5))\n",
        "model.add(Flatten())\n",
        "# model.add(Dense(2,activation='softmax'))\n",
        "model.add(Dense(9,activation='sigmoid'))\n",
        "\n",
        "# defining f1_scroe mteric algorithm\n",
        "def f1_score(y_true, y_pred):\n",
        "    true_positives_values = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n",
        "    possible_positive_value = K.sum(K.round(K.clip(y_true, 0, 1)))\n",
        "    predicted_positives_value = K.sum(K.round(K.clip(y_pred, 0, 1)))\n",
        "    precision = true_positives_values / (predicted_positives_value + K.epsilon())\n",
        "    recall = true_positives_values / (possible_positive_value + K.epsilon())\n",
        "    f1_val = 2*(precision*recall)/(precision+recall+K.epsilon())\n",
        "    return f1_val\n",
        "\n",
        "# Model metrics options\n",
        "METRICS = [BinaryAccuracy(name='accuracy'),Precision(name='precision'),Recall(name='recall'),AUC(name='auc'),f1_score]\n",
        "\n",
        "# Using this we can improve out effciency of traning\n",
        "# This primarily Reduces learning rate when a metric has stopped improving.\n",
        "\n",
        "reducelr_plateau = ReduceLROnPlateau(monitor = 'val_loss',patience = 5,verbose = 1,factor = 0.75, min_lr = 1e-10)\n",
        "\n",
        "# create a model checkpoint (save a model locally so to be used later.) \n",
        "# A checkpoint works like a race checkpoint. Even if model has stoped training in the middle, one can continue traning from that checkpoint\n",
        "model_checkpoint = ModelCheckpoint(filepath=path+str(datetime.now()) + 'VGG16_model.h5',save_freq='epoch',period=1)\n",
        "\n",
        "# This will stop training when a monitored metric has stopped improving\n",
        "early_stopping = EarlyStopping(verbose=1, patience=5)\n",
        "\n",
        "# Configuring our model\n",
        "model.compile(optimizer='Adam', loss='binary_crossentropy',metrics=METRICS)\n",
        "\n",
        "# Training\n",
        "history=model.fit(X_train, y_train,validation_data=(X_test, y_test),verbose = 1,epochs = 3,callbacks=[reducelr_plateau,model_checkpoint,early_stopping])\n",
        "\n",
        "# serialize model architecture to JSON\n",
        "model_json = model.to_json()\n",
        "with open(path+str(datetime.now())+\"VGG16_model.json\", \"w\") as json_file:\n",
        "    json_file.write(model_json)\n",
        "# with open(path+str(datetime.now())+'VGG16_history.pkl', 'wb') as output:\n",
        "#   pickle.dump(idc_class_0_array, output, pickle.HIGHEST_PROTOCOL)\n",
        "# serialize weights to HDF5\n",
        "# model.save_weights(\"model.h5\")\n",
        "print(\"Saved model to disk\")\n",
        "#%% PLOTTING RESULTS (Train vs Validation FOLDER 1)\n",
        "\n",
        "# Function to create model training stats\n",
        "def train_Validation_plot(acc,val_acc,loss,val_loss,auc,val_auc,precision,val_precision,f1,val_f1):\n",
        "    fig, (ax1, ax2,ax3,ax4,ax5) = plt.subplots(1,5, figsize= (20,5))\n",
        "    fig.suptitle(\"Visualization of Model\")\n",
        "    \n",
        "    # Figure 1\n",
        "    fig,ax = plt.subplots(figsize= (20,5))\n",
        "    ax.plot(range(1, len(acc) + 1), acc)\n",
        "    ax.plot(range(1, len(val_acc) + 1), val_acc)\n",
        "    ax.set_title('Accuracy')\n",
        "    ax.set_xlabel('Epochs')\n",
        "    ax.set_ylabel('Accuracy')\n",
        "    ax.legend(['training', 'validation'])\n",
        "    \n",
        "    # Figure 2\n",
        "    fig,ax = plt.subplots(figsize= (20,5))\n",
        "    ax.plot(range(1, len(loss) + 1), loss)\n",
        "    ax.plot(range(1, len(val_loss) + 1), val_loss)\n",
        "    ax.set_title('Loss Curve')\n",
        "    ax.set_xlabel('Epochs')\n",
        "    ax.set_ylabel('Loss')\n",
        "    ax.legend(['training', 'validation'])\n",
        "    \n",
        "    # Figure 3\n",
        "    fig,ax = plt.subplots(figsize= (20,5))\n",
        "    ax.plot(range(1, len(auc) + 1), auc)\n",
        "    ax.plot(range(1, len(val_auc) + 1), val_auc)\n",
        "    ax.set_title('AUC Curve')\n",
        "    ax.set_xlabel('Epochs')\n",
        "    ax.set_ylabel('AUC')\n",
        "    ax.legend(['training', 'validation'])\n",
        "    \n",
        "    # Figure 4\n",
        "    fig,ax = plt.subplots(figsize= (20,5))\n",
        "    ax.plot(range(1, len(precision) + 1), precision)\n",
        "    ax.plot(range(1, len(val_precision) + 1), val_precision)\n",
        "    ax.set_title('Precision')\n",
        "    ax.set_xlabel('Epochs')\n",
        "    ax.set_ylabel('Precision')\n",
        "    ax.legend(['training', 'validation'])\n",
        "    \n",
        "    # Figure 5\n",
        "    fig,ax = plt.subplots(figsize= (20,5))\n",
        "    ax.plot(range(1, len(f1) + 1), f1)\n",
        "    ax.plot(range(1, len(val_f1) + 1), val_f1)\n",
        "    ax.set_title('F1-score')\n",
        "    ax.set_xlabel('Epochs')\n",
        "    ax.set_ylabel('F1 score')\n",
        "    ax.legend(['training', 'validation'])\n",
        "    \n",
        "    plt.show()\n",
        "\n",
        "# Getting model stats Graph\n",
        "train_Validation_plot(history.history['accuracy'],history.history['val_accuracy'],history.history['loss'],history.history['val_loss'],history.history['auc'],history.history['val_auc'],history.history['precision'],history.history['val_precision'],history.history['f1_score'],history.history['val_f1_score'])\n",
        "final_model=model\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WeUFodyFBUUI"
      },
      "source": [
        "saved_model_config_path = '/content/drive/MyDrive/2021-11-02 07:22:18.859958VGG16_model.json'\n",
        "saved_model_weights_path = '/content/drive/MyDrive/2021-11-02 06:54:54.906552VGG16_model.h5'\n",
        "json_file = open(saved_model_config_path, 'r')\n",
        "loaded_model_json = json_file.read()\n",
        "json_file.close()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YmP1cliNBCaY",
        "outputId": "3489da3b-36f3-47a8-f85f-a6045d6c7893"
      },
      "source": [
        "loaded_model = model_from_json(loaded_model_json)\n",
        "# load weights into new model\n",
        "loaded_model.load_weights(saved_model_weights_path)\n",
        "print(\"Loaded model from disk\")\n",
        "  \n",
        "# evaluate loaded model on test data\n",
        "loaded_model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy'])\n",
        "# score = loaded_model.evaluate(X, np.array(y), verbose=0)\n",
        "# print(\"%s: %.2f%%\" % (loaded_model.metrics_names[1], score[1]*100))\n",
        "final_model=loaded_model"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Loaded model from disk\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZefVGCuO-fng"
      },
      "source": [
        "# test_img_path= '/content/drive/MyDrive/0a7899ed6a15f4af8f28e01c9c44dcfe.jpg'\n",
        "# img = cv2.imread(test_img_path,cv2.IMREAD_COLOR)\n",
        "# img_sized = cv2.resize(img, (128, 128), interpolation=cv2.INTER_LINEAR)\n",
        "# Xnew = np.array(img_sized).reshape(-1,128, 128, 3)\n",
        "# ynew = final_model.predict(Xnew)\n",
        "# pred=ynew.tolist()\n",
        "# unique_label[pred[0].index(max(pred[0]))]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bjUQo7BsEZWT"
      },
      "source": [
        "unique_label=list(unique_label)\n",
        "y_pred=[]\n",
        "i=0\n",
        "for img in X_val:\n",
        "  img = np.array(img).reshape(-1,64, 64, 3)\n",
        "  ynew = final_model.predict(img)\n",
        "  pred = ynew.tolist()\n",
        "  temp=unique_label[pred[0].index(max(pred[0]))]\n",
        "  print(f\"{i} = {temp}\")\n",
        "  y_pred.append(temp)\n",
        "  i+=1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BtdV4pSlSU9F"
      },
      "source": [
        "import matplotlib as mpl\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.pylab as pylab\n",
        "import seaborn as sns\n",
        "import missingno as msno\n",
        "from sklearn.metrics import confusion_matrix, classification_report"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FsE8LM7nSBR8"
      },
      "source": [
        "def plot_confusion_matrix(cm,\n",
        "                          target_names,\n",
        "                          title='Confusion matrix',\n",
        "                          cmap=None,\n",
        "                          normalize=True):\n",
        "    import matplotlib.pyplot as plt\n",
        "    import numpy as np\n",
        "    import itertools\n",
        "\n",
        "    accuracy = np.trace(cm) / np.sum(cm).astype('float')\n",
        "    misclass = 1 - accuracy\n",
        "\n",
        "    if cmap is None:\n",
        "        cmap = plt.get_cmap('Blues')\n",
        "\n",
        "    plt.figure(figsize=(15, 10))\n",
        "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
        "    plt.title(title)\n",
        "    plt.colorbar()\n",
        "\n",
        "    if target_names is not None:\n",
        "        tick_marks = np.arange(len(target_names))\n",
        "        plt.xticks(tick_marks, target_names, rotation=45)\n",
        "        plt.yticks(tick_marks, target_names)\n",
        "\n",
        "    if normalize:\n",
        "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
        "\n",
        "\n",
        "    thresh = cm.max() / 1.5 if normalize else cm.max() / 2\n",
        "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
        "        if normalize:\n",
        "            plt.text(j, i, \"{:0.4f}\".format(cm[i, j]),\n",
        "                     horizontalalignment=\"center\",\n",
        "                     color=\"white\" if cm[i, j] > thresh else \"black\")\n",
        "        else:\n",
        "            plt.text(j, i, \"{:,}\".format(cm[i, j]),\n",
        "                     horizontalalignment=\"center\",\n",
        "                     color=\"white\" if cm[i, j] > thresh else \"black\")\n",
        "\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.ylabel('True label')\n",
        "    plt.xlabel('Predicted label\\naccuracy={:0.4f}; misclass={:0.4f}'.format(accuracy, misclass))\n",
        "    plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IgzUtbPOxgsw",
        "outputId": "8e89c6df-c3ef-4df1-87cc-87c73d2c7f9f"
      },
      "source": [
        "print(type(y_val))\n",
        "print(len(y_pred))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'list'>\n",
            "4203\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 757
        },
        "id": "BzaDcHCWxeLg",
        "outputId": "b8fb7c9e-b335-4f3f-f7ac-0da4abd7fcde"
      },
      "source": [
        "all_labels_list=y_val\n",
        "all_preds_list=y_pred\n",
        "plot_confusion_matrix(cm=confusion_matrix(y_true=all_labels_list, y_pred=all_preds_list), target_names=specices, normalize=False)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x720 with 2 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9ywi3lnUcENv",
        "outputId": "fc37886d-67a9-41f1-c3e0-9fb9986e842f"
      },
      "source": [
        "from sklearn.metrics import classification_report\n",
        "print(classification_report(y_val, y_pred, target_names=specices))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "                precision    recall  f1-score   support\n",
            "\n",
            "  Chinee apple       0.31      0.15      0.20       274\n",
            "       Lantana       0.35      0.40      0.38       253\n",
            "      Negative       0.28      0.84      0.42       270\n",
            "    Snake weed       0.44      0.24      0.31       248\n",
            "     Siam weed       0.72      0.18      0.29       264\n",
            "Prickly acacia       0.50      0.13      0.20       238\n",
            "    Parthenium       0.54      0.27      0.37       251\n",
            "   Rubber vine       0.40      0.33      0.36       240\n",
            "   Parkinsonia       0.68      0.75      0.71      2165\n",
            "\n",
            "      accuracy                           0.54      4203\n",
            "     macro avg       0.47      0.37      0.36      4203\n",
            "  weighted avg       0.56      0.54      0.52      4203\n",
            "\n"
          ]
        }
      ]
    }
  ]
}