text: # -----------------Made by Shashwat 
  # python train_mask_detector.py --dataset dataset
  
  # import the necessary packages
  from tensorflow.keras.preprocessing.image import ImageDataGenerator
  from tensorflow.keras.applications import MobileNetV2
  from tensorflow.keras.layers import AveragePooling2D
  from tensorflow.keras.layers import Dropout
  from tensorflow.keras.layers import Flatten
  from tensorflow.keras.layers import Dense
  from tensorflow.keras.layers import Input
  from tensorflow.keras.models import Model
  from tensorflow.keras.optimizers import Adam
  from tensorflow.keras.applications.mobilenet_v2 import preprocess_input
  from tensorflow.keras.preprocessing.image import img_to_array
  from tensorflow.keras.preprocessing.image import load_img
  from tensorflow.keras.utils import to_categorical
  from sklearn.preprocessing import LabelBinarizer
  from sklearn.model_selection import train_test_split
  from sklearn.metrics import classification_report
  from imutils import paths
  import matplotlib.pyplot as plt
  import numpy as np
  import argparse
  import os
  
  
  ap = argparse.ArgumentParser()
  ap.add_argument("-d", "--dataset", required=True,
  	help="path to input dataset")
  ap.add_argument("-p", "--plot", type=str, default="plot.png",
  	help="path to output loss/accuracy plot")
  ap.add_argument("-m", "--model", type=str,
  	default="mask_detector.model",
  	help="path to output face mask detector model")
  args = vars(ap.parse_args())
  
  #Setting some parameters
  INIT_LR = 1e-4
  EPOCHS = 20
  BS = 32
  
  print("[INFO] loading images...")
  imagePaths = list(paths.list_images(args["dataset"]))
  data = []
  labels = []
  
  
  for imagePath in imagePaths:
  	
  	label = imagePath.split(os.path.sep)[-2]
  
  	# Input image (224x224) 
  	image = load_img(imagePath, target_size=(224, 224))
  	image = img_to_array(image)
  	image = preprocess_input(image)
  
  
  	data.append(image)
  	labels.append(label)
  
  data = np.array(data, dtype="float32")
  labels = np.array(labels)
  
  # One-hot Encoding 
  lb = LabelBinarizer()
  labels = lb.fit_transform(labels)
  labels = to_categorical(labels)
  
  
  (trainX, testX, trainY, testY) = train_test_split(data, labels,
  	test_size=0.20, stratify=labels, random_state=42)
  
  # construct the training image generator for data augmentation
  aug = ImageDataGenerator(
  	rotation_range=20,
  	zoom_range=0.15,
  	width_shift_range=0.2,
  	height_shift_range=0.2,
  	shear_range=0.15,
  	horizontal_flip=True,
  	fill_mode="nearest")
  
  # load the MobileNetV2 network, ensuring the head FC layer sets are
  # left off
  baseModel = MobileNetV2(weights="imagenet", include_top=False,
  	input_tensor=Input(shape=(224, 224, 3)))
  
  # construct the head of the model that will be placed on top of the
  # the base model
  headModel = baseModel.output
  headModel = AveragePooling2D(pool_size=(7, 7))(headModel)
  headModel = Flatten(name="flatten")(headModel)
  headModel = Dense(128, activation="relu")(headModel)
  headModel = Dropout(0.5)(headModel)
  headModel = Dense(2, activation="softmax")(headModel)
  
  # place the head FC model on top of the base model (this will become
  # the actual model we will train)
  model = Model(inputs=baseModel.input, outputs=headModel)
  
  # loop over all layers in the base model and freeze them so they will
  # *not* be updated during the first training process
  for layer in baseModel.layers:
  	layer.trainable = False
  
  # compile our model
  print("[INFO] compiling model...")
  opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)
  model.compile(loss="binary_crossentropy", optimizer=opt,
  	metrics=["accuracy"])
  
  
  print("[INFO] training head...")
  H = model.fit(
  	aug.flow(trainX, trainY, batch_size=BS),
  	steps_per_epoch=len(trainX) // BS,
  	validation_data=(testX, testY),
  	validation_steps=len(testX) // BS,
  	epochs=EPOCHS)
  
  
  print("[INFO] evaluating network...")
  predIdxs = model.predict(testX, batch_size=BS)
  
  
  predIdxs = np.argmax(predIdxs, axis=1)
  
  # Report of model 
  print(classification_report(testY.argmax(axis=1), predIdxs,
  	target_names=lb.classes_))
  
  
  print("[INFO] saving mask detector model...")
  model.save(args["model"], save_format="h5")
  
  # plot the training loss and accuracy
  N = EPOCHS
  plt.style.use("ggplot")
  plt.figure()
  plt.plot(np.arange(0, N), H.history["loss"], label="train_loss")
  plt.plot(np.arange(0, N), H.history["val_loss"], label="val_loss")
  plt.plot(np.arange(0, N), H.history["accuracy"], label="train_acc")
  plt.plot(np.arange(0, N), H.history["val_accuracy"], label="val_acc")
  plt.title("Training Loss and Accuracy")
  plt.xlabel("Epoch #")
  plt.ylabel("Loss/Accuracy")
  plt.legend(loc="lower left")
  plt.savefig(args["plot"])
  