Posted on Nov 21, 2020

End to end Mask detection

#deeplearning #python #opencv #machinelearning

Table of content

1.Collect Data

Data Preprocessing
Visualizing Data
Build Model
Train model
Evaluating Trained Model
Save a trained model
Predict on custom data
Realtime detection

1.Collect data

In every machine learning, problem data is the main.
here, data is collected from Kaggle.
data is a subset of this dataset you can download it from here

2.Data Preprocessing

Before we process data, first structure our data in the right folder.
For this we have two option:

Use TensorFlow image_dataset_from_directory.
load CSV file.

Here we choose to load from a CSV file.
For that, we change the image name to withmask and withoutmask.

Withmask

# importing os module import os # Function to rename multiple files def main(): for count, filename in enumerate(os.listdir("DATASET/")): dst ="withmask." + str(count) + ".jpeg" src ='DATASET/'+ filename dst ='DATASET/'+ dst # rename() function will # rename all the files os.rename(src, dst) # Driver Code if __name__ == '__main__': # Calling main() function main()

Withoutmask

# importing os module import os # Function to rename multiple files def main(): for count, filename in enumerate(os.listdir("New folder/")): dst ="withoutmask." + str(count) + ".jpeg" src ='New folder/'+ filename dst ='New folder/'+ dst # rename() function will # rename all the files os.rename(src, dst) # Driver Code if __name__ == '__main__': # Calling main() function main()

Now move all images into one folder and create a pandas data frame

Generate DataFrame

import pandas as pd filenames=os.listdir("FULL_DATA/") categories=[] for f_name in filenames: category=f_name.split('.')[0] if category=='withmask': categories.append('withmask') else: categories.append('withoutmask') df=pd.DataFrame({ 'filename':filenames, 'labels':categories })

Save dataFrame into CSV file.

Now data is in the right structure we can load data

Read CSV file
Shuffle DataFrame with sample(frac=1)
Turn label into an Array of Boolean
Create a validation set with train_test_split
Turning images into Tensor

# Define image size IMG_SIZE = 224 # Function def process_image(image_path, image_size=IMG_SIZE): """ Takes an image file path and turns the image into a Tensor. """ # Read in an image file image = tf.io.read_file(image_path) # Turn the jpg image into numerical Tensor with 3 colour channel(RGB) image = tf.image.decode_jpeg(image,channels=3) # Convert the color channel values to (0-1) values image = tf.image.convert_image_dtype(image,tf.float32) # Resize the image to (224,224) image = tf.image.resize(image, size=[image_size,image_size]) return image

Turning data into Batches

# Create a function to return a tuple (image, label) def get_image_lable(image_path,label): """ Takes an image file path name and the label, processes the image and return a tuple (image, label). """ image = process_image(image_path) return image, label

# Define the batch size BATCH_SIZE = 32 # Function to convert data into batches def create_data_batches(X,y=None, batch_size=BATCH_SIZE,valid_data=False): """ Creates batches of data of image (X) and label (y) pairs. Shuffle the data if it's training data but doesn't shuffle if it's validation data. """ # If data is valid dataset (NO SHUFFLE) if 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("Creating train data batches.........") # Turn filepaths and labels into Tensors data = tf.data.Dataset.from_tensor_slices((tf.constant(X), tf.constant(y))) # Shuffling pathname and labels before mapping image processor fun data = data.shuffle(buffer_size=len(X)) data_batch = data.map(get_image_lable).batch(batch_size) return data_batch

3.Visulizing Data

import matplotlib.pyplot as plt # Create fun for viewing in a data batch def show_images(images, labels): """ Displays a plot of 25 images and their labels from a data batch. """ plt.figure(figsize=(20, 20)) for i in range(25): # Subplot ax = plt.subplot(5,5,i+1) plt.imshow(images[i]) plt.title(unique_category[labels[i].argmax()]) plt.axis("Off")

Call this fun

For Train data

train_images, train_labels = next(train_data.as_numpy_iterator()) show_images(train_images,train_labels)

For valid Data

val_images, val_labels = next(val_data.as_numpy_iterator()) show_images(val_images, val_labels)

4.Building a model

Here we can use the TensorFlow hub for pre-trained models.
For this task, we use MobileNet V2 which is a small model.

Set input_shape = [none, 224,224,3]
Set output_shape = 2
Use Sequential model from tf.keras

# Create a fun to build a keras model def create_model(input_shape=INPUT_SHAPE,output_shape=OUTPUT_SHAPE, model_url=MODEL_URL): print("Building model with:", model_url) # Setup the model model = tf.keras.Sequential([ hub.KerasLayer(model_url), tf.keras.layers.Dense(units=output_shape, activation="softmax") ]) # Compile the model model.compile( loss = tf.keras.losses.BinaryCrossentropy(), optimizer = tf.keras.optimizers.Adam(), metrics = ["accuracy"] ) # Build the model model.build(input_shape) return model

5. Train a model

Train a model on train_data and valid_data for 25 EPOCHS

Also, add an Early stopping callback

model = create_model() model.summary()

With this model, val_loss is 0.0096 and Accuracy is almost 99.99 %

6.Evaluating prediction

Using model.predict() on val_data model return NumPy array of shape (_ , 2)

7.Saving and reloading a trained model

Save a trained model using save_model from keras.

Loading a model is a bit different from regular load_model

model = load_model( 'model/model.h5', custom_objects={"KerasLayer": hub.KerasLayer})

here we have to provide custom_objects={“KerasLayer”: hub.KerasLayer} in load_model function alongside model_path.

8.Predict on custom data

Before predicting the new data make sure it is in the right shape as well as the right size.

def test_data(path): demo = imread(path) demo = tf.image.convert_image_dtype(demo,tf.float32) demo = tf.image.resize(demo,size=[224,224]) demo = np.expand_dims(demo,axis=0) pred = model.predict(demo) result = unique_category[np.argmax(pred)] return result