Dog Breed Classification

Radhesh started speaking,

Hello Everyone this is the new blog about the project named as Dog Breed Classification,this project is based on CNN(convolutional neural network).

Description of Dataset:

Here we have a 10,000 image dataset of various Dog Breeds and each breed is a seperate class ,there is total 120 classes are present in the dataset

• I downloaded the Dataset from:

Platform discription:

After downloading the dataset ,i had imports the dataset into a Google Drive, Now,you have a question in your mind that Heyy! Radhesh Why you used a Google Drive If you can easily store it on your pc?

The answer is: i had to use a Google colab .

Google Colab: Colaboratory, or “Colab” for short, is a product from Google Research. Colab allows anybody to write and execute arbitrary python code through the browser, and is especially well suited to machine learning, data analysis and education.

• But the sole benifit is it provides a Free GPU For Faster Processing

Starting Of Project:

• Imporing necessory Libraries:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

in this project i had used a Tensorflow and Keras

If you Want to know more about tensorflow and Keras, please visit here

• Importing Tensorflow and Keras:

import tensorflow as tf
#Importing tensorflow_hub
import tensorflow_hub as hub
print("version of tensorflow:",tf.__version__)
print("version of tensorflow_hub:",hub.__version__)
#checking for GPU
print("GPU","AVAILABLE :)"if tf.config.list_physical_devices("GPU") else "not Available :(")

Output:

• version of tensorflow: 2.4.1,
• version of tensorflow_hub: 0.12.0,
• GPU AVAILABLE :)

After importing the necessary libraries

I setuped the Path For Dataset ,so i can import it to my colab notebook

path='drive/MyDrive/dog-vision/train/'

Read the dataset:

lable=pd.read_csv('/content/drive/MyDrive/dog-vision/labels.csv')

Let's check the dataset by visualization:

lable['breed'].value_counts().plot.bar(figsize=(20,10));

Output:

CHECKING THE FILENAME MATCHESH THE NO. OF DATA IN TRAIN FOLDER:-

filename=[path + fname + '.jpg' for fname in lable['id']]
len_file=filename[:10]

import os
if len(os.listdir(path)[:10])==len(len_file):
  print("length of data in filename matched with actual data in train folder")
else:
  print('not matched')

Output: length of data in filename matched with actual data in train folder

• Storing the labels of dataset:

lables=lable['breed']
lables

Output:

0 boston_bull 1 dingo 2 pekinese 3 bluetick 4 golden_retriever ...
10217 borzoi 10218 dandie_dinmont 10219 airedale 10220 miniature_pinscher 10221 chesapeake_bay_retriever Name: breed, Length: 10222, dtype: object

Now, Converting the labels to an array

lables=lable['breed'].to_numpy()
lables

Output:

array(['boston_bull', 'dingo', 'pekinese', ..., 'airedale', 'miniature_pinscher', 'chesapeake_bay_retriever'], dtype=object)

• Creating a set of unique labels:

unique=np.unique(lables)
print(f'uniques is:{unique}#############length is:{len(unique)}')

Output:

From above image we can also verified that there is 120 unique classes

Turning labels into boolean array:

boolean_lables=[lab==unique for lab in lables]
boolean_lables[:2]

Output:

Creating Validation Set of Data:-

Creating and setting up our x & y variables:-

x=filename
y=boolean_lables

Now,splitting the validation dataset into train and test :-

from sklearn.model_selection import  train_test_split
X_train,X_val,y_train,y_val=train_test_split(x[:NUM_IMAGES],
                                             y[:NUM_IMAGES],
                                             test_size=0.2,random_state=42)
len(X_train),len(X_val),len(y_train),len(y_val)

Output:- (800, 200, 800, 200)

After splitting we have to convert the image dataset into tensor so it can bo fittable into our tensorflow model To do this we have to write :

from matplotlib.pyplot import imread
image=plt.imread(filename[42])
image.shape

Output: (257, 350, 3)

Now,lets create a function to to turn it into (224,224)

IMG_SIZE=224

def preprocess_img(image_path):
  '''takes image file path and turn it into tensor'''
  # read img path into image
  image=tf.io.read_file(image_path)
  # turn thr jpg image into Tensors:-
  image=tf.image.decode_jpeg(image,channels=3)
  #Convert the color channel value into 0-255 to 0-1
  image=tf.image.convert_image_dtype(image,tf.float32)
  #Resize the image:-
  image=tf.image.resize(image,size=[IMG_SIZE,IMG_SIZE])

  return image

Now,Let's create a function which return a tuple(image,lable):-

def get_image_lable(img_path,lables):
  image=preprocess_img(img_path)
  return image,lables

• Create a Batch of dataset:

BATCH_SIZE=32

def  create_batch(X,y=None,batch_size=BATCH_SIZE,valid_data=False,test_data=False):
   if test_data:
     print('creating test_data batches....')
     data=tf.data.Dataset.from_tensor_slices(tf.constant(X))
     data_batch=data.map(preprocess_img).batch(BATCH_SIZE)
     return data_batch

  elif  valid_data:
     print('creating valid_data batches...')
     data=tf.data.Dataset.from_tensor_slices((tf.constant(X),
                                             tf.constant(y)))
     data_batch=data.map(get_image_lable).batch(BATCH_SIZE)
     return data_batch

  else:
     print('create training_batch....')
     data=tf.data.Dataset.from_tensor_slices((tf.constant(X),
                                             tf.constant(y)))
     data=data.shuffle(buffer_size=len(X))

     data_batch=data.map(get_image_lable).batch(BATCH_SIZE)
     return data_batch

train_data=create_batch(X_train,y_train)
val_data=create_batch(X_val,y_val,valid_data=True)

Checking our Batch:

train_data.element_spec,val_data.element_spec

Output:-

((TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name=None), TensorSpec(shape=(None, 120), dtype=tf.bool, name=None)), (TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name=None), TensorSpec(shape=(None, 120), dtype=tf.bool, name=None)))

• Visualising the DataBatch:-

def show_img(images,lable):
  '''
  Displayes a plot of images from data batch
  '''
  plt.figure(figsize=(10,10))
  for i in range(25):
    ax = plt.subplot(5,5,i+1)
    plt.imshow(images[i])
    plt.title(unique[lable[i].argmax()])
    plt.axis('off')
train_images,train_lables=next(train_data.as_numpy_iterator())

show_img(train_images,train_lables)

Output:-

• Building Model:-

  To building the model i had used the imagenet(it is the pretrained model for boosting the performance and accuracy of our own model) .

  To use this copy and paste the link:-

#input shape:-
INPUT_SIZE=[None,IMG_SIZE,IMG_SIZE,3]#batch ,height ,width,color-channel
#output shape:-
OUTPUT_SIZE=len(unique)
#setup Model url from tensorflow_hub:-
MODEL_URL='https://tfhub.dev/google/imagenet/mobilenet_v2_130_224/classification/4'

def create_model(input_shape=INPUT_SIZE,output_shape=OUTPUT_SIZE,model_url=MODEL_URL):
  print('creating model with:',MODEL_URL)

  model=tf.keras.Sequential([
                             hub.KerasLayer(model_url),#1st layer input layer
                             tf.keras.layers.Dense(units=output_shape,activation='softmax')#output layer

  ])

  model.compile(
      loss=tf.keras.losses.CategoricalCrossentropy(),
      optimizer=tf.keras.optimizers.Adam(),
      metrics=['accuracy']
  )
  model.build(input_shape)
  return model

models=create_model()
models.summary()

Output:-

Now,creating the logdirectory for tensorbord:-

Loading the tensorbord:-

%load_ext tensorboard

import datetime
import os
def create_tb_callback():
  log_dir=os.path.join('/content/drive/MyDrive/dog-vision/logs',
                       datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))
  return tf.keras.callbacks.TensorBoard(log_dir)

create early stopping callbacks:-

early_stopping=tf.keras.callbacks.EarlyStopping(monitor='val_accuracy',
                                                patience=3)

Now,fit the datasets into our model:-

#creating a function to train model:-
def train_model():
  model=create_model()
  tensorboard=create_tb_callback()
  model.fit(x=train_data,
            epochs=NUM_EPOCHS,
            validation_data=val_data,
            validation_freq=1,
            callbacks=[tensorboard,early_stopping])
  return model

model=train_model()

Output:-

So,our model is now,trained with good accuracy :)

Loading Tensorboard result:-

So,this the end of my project "Dog breed Classification" hope you will like it, next time i will came back with new projects till then Thank you :)