Tea Leaf Disease Classification with InceptionResNetV2

Download original notebook: Tea

from zipfile import ZipFile
file_name = "/content/data.zip"
with ZipFile(file_name,'r')as zip:
  zip.extractall()
  print('Done')

# This Python 3 environment comes with many helpful analytics libraries installed
# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python
# For example, here's several helpful packages to load

import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)

# Input data files are available in the read-only "../input/" directory
# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory

import os
for dirname, _, filenames in os.walk('/kaggle/input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))

# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using "Save & Run All" 
# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session

import numpy as np
import tensorflow as tf
from tensorflow import keras
import cv2
import matplotlib.pyplot as plt
%matplotlib inline
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Layer
import pickle
import os
from keras.preprocessing.image import img_to_array
from keras.applications.inception_resnet_v2 import InceptionResNetV2
from keras.layers import GlobalMaxPooling2D, Dense, GlobalAveragePooling2D
from keras.applications.inception_resnet_v2 import preprocess_input
from tensorflow.keras.models import Model
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split

default_image_size = tuple((229, 229))

def convert_image_to_array(image_dir):
    try:
        image = cv2.imread(image_dir)
        if image is not None :
            image = cv2.resize(image, default_image_size)
            x = img_to_array(image)
            return x #np.expand_dims(x, axis=0)
        else :
            return np.array([])
    except Exception as e:
        print(f"Error : {e}")
        return None

image_list,label_list = [],[]
directory_root = '/content/testfinal'


#default_image_size = (229,229)
try:
    print("[INFO] Loading images ...")
    root_dir = os.listdir(directory_root)
    for directory in root_dir :
        # remove .DS_Store from list
        if directory == ".DS_Store" :
            root_dir.remove(directory)

    for plant_folder in root_dir :
        plant_disease_folder_list = os.listdir(f"{directory_root}/{plant_folder}")
        
        for disease_folder in plant_disease_folder_list :
            # remove .DS_Store from list
            if disease_folder == ".DS_Store" :
                plant_disease_folder_list.remove(disease_folder)

        for plant_disease_folder in plant_disease_folder_list:
            print(f"[INFO] Processing {plant_disease_folder} ...")
            plant_disease_image_list = os.listdir(f"{directory_root}/{plant_folder}/{plant_disease_folder}/")
                
            for single_plant_disease_image in plant_disease_image_list :
                if single_plant_disease_image == ".DS_Store" :
                    plant_disease_image_list.remove(single_plant_disease_image)

            for image in plant_disease_image_list[:200]:
                image_directory = f"{directory_root}/{plant_folder}/{plant_disease_folder}/{image}"
                if image_directory.endswith(".jpg") == True or image_directory.endswith(".JPG") == True:
                    image_list.append(convert_image_to_array(image_directory))
                    label_list.append(plant_disease_folder)
    print("[INFO] Image loading completed")  
except Exception as e:
    print(f"Error : {e}")

#np_label = np.asarray(label_list)
np_image_list = np.array(image_list, dtype=np.float16)
#print("Total no. of y:{}".format(np_label.shape))
#print("Total no. of images:{}".format(image_list.shape))

softmax_output = len(plant_disease_folder_list)

label_binarizer = LabelBinarizer()
image_labels = label_binarizer.fit_transform(label_list)
pickle.dump(label_binarizer,open('label_transform.pkl', 'wb'))
n_classes = len(label_binarizer.classes_)
print(n_classes)

X_train,X_test,Y_train,Y_test = train_test_split(np_image_list,image_labels,test_size=0.2,random_state=42)

model = InceptionResNetV2(include_top=False,
    weights="imagenet")

X = model.output

X = GlobalMaxPooling2D()(X)

predictions = Dense(softmax_output, activation='softmax')(X)

aug = ImageDataGenerator(
    rotation_range=25, width_shift_range=0.1,
    height_shift_range=0.1, shear_range=0.2, 
    zoom_range=0.2,horizontal_flip=True, 
    fill_mode="nearest")

# Hyper parameters

batch_size = 16
epochs = 40
INIT_LR = 1e-3
my_callbacks = [
    tf.keras.callbacks.TensorBoard(log_dir='./logs'),
]

opt = tf.keras.optimizers.Adam(lr=INIT_LR, decay=INIT_LR / epochs)

Inception_Resnet_model = Model(inputs=model.input, outputs=predictions)

Inception_Resnet_model.compile(optimizer=opt, loss='categorical_crossentropy',metrics=["accuracy"])

#Complete model
Inception_Resnet_model.summary()

Inception_Resnet_model.fit(
    aug.flow(X_train, Y_train, batch_size=16),
    batch_size=batch_size,
    epochs=epochs,
    callbacks=my_callbacks,
    validation_data=(X_test, Y_test),
    shuffle=True
    
)