Upload 10 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+shape_predictor_68_face_landmarks.dat filter=lfs diff=lfs merge=lfs -text
+yolov4.weights filter=lfs diff=lfs merge=lfs -text

PreTrained_coco.names

@@ -0,0 +1,80 @@
+person
+bicycle
+car
+motorbike
+aeroplane
+bus
+train
+truck
+boat
+traffic light
+fire hydrant
+stop sign
+parking meter
+bench
+bird
+cat
+dog
+horse
+sheep
+cow
+elephant
+bear
+zebra
+giraffe
+backpack
+umbrella
+handbag
+tie
+suitcase
+frisbee
+skis
+snowboard
+sports ball
+kite
+baseball bat
+baseball glove
+skateboard
+surfboard
+tennis racket
+bottle
+wine glass
+cup
+fork
+knife
+spoon
+bowl
+banana
+apple
+sandwich
+orange
+broccoli
+carrot
+hot dog
+pizza
+donut
+cake
+chair
+sofa
+pottedplant
+bed
+diningtable
+toilet
+tvmonitor
+laptop
+mouse
+remote
+keyboard
+cell phone
+microwave
+oven
+toaster
+sink
+refrigerator
+book
+clock
+vase
+scissors
+teddy bear
+hair drier
+toothbrush

PreTrained_yolov4.cfg

@@ -0,0 +1,1157 @@
+[net]
+batch=64
+subdivisions=8
+# Training
+#width=512
+#height=512
+width=608
+height=608
+channels=3
+momentum=0.949
+decay=0.0005
+angle=0
+saturation = 1.5
+exposure = 1.5
+hue=.1
+
+learning_rate=0.0013
+burn_in=1000
+max_batches = 500500
+policy=steps
+steps=400000,450000
+scales=.1,.1
+
+#cutmix=1
+mosaic=1
+
+#:104x104 54:52x52 85:26x26 104:13x13 for 416
+
+[convolutional]
+batch_normalize=1
+filters=32
+size=3
+stride=1
+pad=1
+activation=mish
+
+# Downsample
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=3
+stride=2
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=1
+stride=1
+pad=1
+activation=mish
+
+[route]
+layers = -2
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=32
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=1
+stride=1
+pad=1
+activation=mish
+
+[route]
+layers = -1,-7
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=1
+stride=1
+pad=1
+activation=mish
+
+# Downsample
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=2
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=1
+stride=1
+pad=1
+activation=mish
+
+[route]
+layers = -2
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=64
+size=1
+stride=1
+pad=1
+activation=mish
+
+[route]
+layers = -1,-10
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=mish
+
+# Downsample
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=2
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=mish
+
+[route]
+layers = -2
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=mish
+
+[route]
+layers = -1,-28
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=mish
+
+# Downsample
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=2
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=mish
+
+[route]
+layers = -2
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=mish
+
+[route]
+layers = -1,-28
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=mish
+
+# Downsample
+
+[convolutional]
+batch_normalize=1
+filters=1024
+size=3
+stride=2
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=mish
+
+[route]
+layers = -2
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=mish
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=3
+stride=1
+pad=1
+activation=mish
+
+[shortcut]
+from=-3
+activation=linear
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=mish
+
+[route]
+layers = -1,-16
+
+[convolutional]
+batch_normalize=1
+filters=1024
+size=1
+stride=1
+pad=1
+activation=mish
+
+##########################
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=1024
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+### SPP ###
+[maxpool]
+stride=1
+size=5
+
+[route]
+layers=-2
+
+[maxpool]
+stride=1
+size=9
+
+[route]
+layers=-4
+
+[maxpool]
+stride=1
+size=13
+
+[route]
+layers=-1,-3,-5,-6
+### End SPP ###
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=1024
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[upsample]
+stride=2
+
+[route]
+layers = 85
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[route]
+layers = -1, -3
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=512
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=512
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[upsample]
+stride=2
+
+[route]
+layers = 54
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[route]
+layers = -1, -3
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=256
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=256
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=128
+size=1
+stride=1
+pad=1
+activation=leaky
+
+##########################
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=256
+activation=leaky
+
+[convolutional]
+size=1
+stride=1
+pad=1
+filters=255
+activation=linear
+
+
+[yolo]
+mask = 0,1,2
+anchors = 12, 16, 19, 36, 40, 28, 36, 75, 76, 55, 72, 146, 142, 110, 192, 243, 459, 401
+classes=80
+num=9
+jitter=.3
+ignore_thresh = .7
+truth_thresh = 1
+scale_x_y = 1.2
+iou_thresh=0.213
+cls_normalizer=1.0
+iou_normalizer=0.07
+iou_loss=ciou
+nms_kind=greedynms
+beta_nms=0.6
+max_delta=5
+
+
+[route]
+layers = -4
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=2
+pad=1
+filters=256
+activation=leaky
+
+[route]
+layers = -1, -16
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=512
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=512
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=256
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=512
+activation=leaky
+
+[convolutional]
+size=1
+stride=1
+pad=1
+filters=255
+activation=linear
+
+
+[yolo]
+mask = 3,4,5
+anchors = 12, 16, 19, 36, 40, 28, 36, 75, 76, 55, 72, 146, 142, 110, 192, 243, 459, 401
+classes=80
+num=9
+jitter=.3
+ignore_thresh = .7
+truth_thresh = 1
+scale_x_y = 1.1
+iou_thresh=0.213
+cls_normalizer=1.0
+iou_normalizer=0.07
+iou_loss=ciou
+nms_kind=greedynms
+beta_nms=0.6
+max_delta=5
+
+
+[route]
+layers = -4
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=2
+pad=1
+filters=512
+activation=leaky
+
+[route]
+layers = -1, -37
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=1024
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=1024
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+filters=512
+size=1
+stride=1
+pad=1
+activation=leaky
+
+[convolutional]
+batch_normalize=1
+size=3
+stride=1
+pad=1
+filters=1024
+activation=leaky
+
+[convolutional]
+size=1
+stride=1
+pad=1
+filters=255
+activation=linear
+
+
+[yolo]
+mask = 6,7,8
+anchors = 12, 16, 19, 36, 40, 28, 36, 75, 76, 55, 72, 146, 142, 110, 192, 243, 459, 401
+classes=80
+num=9
+jitter=.3
+ignore_thresh = .7
+truth_thresh = 1
+random=1
+scale_x_y = 1.05
+iou_thresh=0.213
+cls_normalizer=1.0
+iou_normalizer=0.07
+iou_loss=ciou
+nms_kind=greedynms
+beta_nms=0.6
+max_delta=5

SupervisedLearningCNN.py

@@ -0,0 +1,399 @@
+# -*- coding: utf-8 -*-
+"""Untitled8.ipynb
+
+Automatically generated by Colaboratory.
+
+Original file is located at
+    https://colab.research.google.com/drive/1nXE8zcbIHJ-cVLamX0RVlAOgQOrUmFu-
+"""
+
+import os
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras.applications import ResNet50V2
+from tensorflow.keras.applications.resnet_v2 import preprocess_input
+from tensorflow.keras.models import Sequential, Model
+from tensorflow.keras.layers import (Conv2D, MaxPool2D, Flatten, MaxPooling2D, PReLU, Dense, Dropout, BatchNormalization,
+                                     GlobalAveragePooling2D, GaussianNoise)
+from tensorflow.keras.layers.experimental.preprocessing import RandomFlip, RandomRotation,RandomTranslation, RandomZoom, RandomContrast, RandomHeight, RandomWidth
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.callbacks import EarlyStopping
+from tensorflow.keras.callbacks import ModelCheckpoint, LearningRateScheduler
+import cv2
+import matplotlib.pyplot as plt
+
+# Constants
+BASE_PATH = "C:/Users/101231186/Desktop/AML"
+TRAIN_PATH = os.path.join(BASE_PATH, "train_data")
+TEST_PATH = os.path.join(BASE_PATH, "test_data")
+VAL_PATH = os.path.join(BASE_PATH, "val_data")
+num_classes = 4000
+
+def count_directories(path):
+    return len([name for name in os.listdir(path) if os.path.isdir(os.path.join(path, name))])
+
+def create_labels_file(dataset_path, file_name):
+    image_paths, image_labels = [], []
+    class_dirs = sorted([d for d in os.listdir(dataset_path) if os.path.isdir(os.path.join(dataset_path, d))])
+
+    for class_label, class_dir in enumerate(class_dirs):
+        class_dir_path = os.path.join(dataset_path, class_dir)
+        image_files = os.listdir(class_dir_path)
+
+        for image_file in image_files:
+            image_file_path = os.path.join(class_dir_path, image_file)
+            if os.path.isfile(image_file_path):
+                image_paths.append(image_file_path)
+                image_labels.append(class_label)
+
+    with open(file_name, 'w') as f:
+        for path, label in zip(image_paths, image_labels):
+            f.write(f"{path} {label}\n")
+
+def load_labels(file_path, base_img_path):
+    list_IDs, labels = [], {}
+    with open(file_path, 'r') as file:
+        for line in file:
+            relative_image_path, label = line.strip().rsplit(' ', 1)
+            full_image_path = os.path.join(base_img_path, relative_image_path)
+            list_IDs.append(full_image_path)
+            labels[full_image_path] = int(label)
+    return list_IDs, labels
+
+class DataGenerator(keras.utils.Sequence):
+    'Generates data for Keras'
+    def __init__(self, list_IDs, labels, batch_size=32, dim=(224,224), n_channels=3,
+                 n_classes=4000, shuffle=True):
+        'Initialization'
+        self.dim = dim
+        self.batch_size = batch_size
+        self.labels = labels
+        self.list_IDs = list_IDs
+        self.n_channels = n_channels
+        self.n_classes = n_classes
+        self.shuffle = shuffle
+        self.on_epoch_end()
+
+    def __len__(self):
+        'Denotes the number of batches per epoch'
+        return int(np.floor(len(self.list_IDs) / self.batch_size))
+
+    def __getitem__(self, index):
+        'Generate one batch of data'
+        # Generate indexes of the batch
+        indexes = self.indexes[index*self.batch_size:(index+1)*self.batch_size]
+
+        # Find list of IDs
+        list_IDs_temp = [self.list_IDs[k] for k in indexes]
+
+        # Generate data
+        X, y = self.__data_generation(list_IDs_temp)
+
+        return X, y
+
+    def on_epoch_end(self):
+        'Updates indexes after each epoch'
+        self.indexes = np.arange(len(self.list_IDs))
+        if self.shuffle:
+            np.random.shuffle(self.indexes)
+
+    def __data_generation(self, list_IDs_temp):
+        'Generates data containing batch_size samples'
+        # Initialization
+        X = np.empty((self.batch_size, *self.dim, self.n_channels))
+        y = np.empty((self.batch_size), dtype=int)
+
+        # Generate data
+        for i, ID in enumerate(list_IDs_temp):
+            # Load and preprocess the image
+            img = self.load_and_preprocess_image(ID, self.dim)
+            X[i,] = img
+
+            # Store class
+            y[i] = self.labels[ID]
+
+        return X, keras.utils.to_categorical(y, num_classes=self.n_classes)
+
+
+    def load_and_preprocess_image(self, image_path, target_size):
+        # Load the image file
+        image = cv2.imread(image_path)
+        image = cv2.resize(image, target_size)  # Resize image
+        # No need to convert to RGB as preprocess_input will handle it
+        image = preprocess_input(image)  # Use ResNet50V2's preprocess_input
+        return image
+
+# Count directories
+train_classes_count = count_directories(TRAIN_PATH)
+test_classes_count = count_directories(TEST_PATH)
+val_classes_count = count_directories(VAL_PATH)
+print('Total training classes:', train_classes_count)
+print('Total testing classes:', test_classes_count)
+print('Total validation classes:', val_classes_count)
+
+# Create labels files
+create_labels_file(TRAIN_PATH, 'labels_train.txt')
+create_labels_file(TEST_PATH, 'labels_test.txt')
+create_labels_file(VAL_PATH, 'labels_val.txt')
+
+# Load labels and initialize generators
+train_list_IDs, train_labels = load_labels('labels_train.txt', TRAIN_PATH)
+test_list_IDs, test_labels = load_labels('labels_test.txt', TEST_PATH)
+val_list_IDs, val_labels = load_labels('labels_val.txt', VAL_PATH)
+
+training_generator = DataGenerator(train_list_IDs, train_labels)
+testing_generator = DataGenerator(test_list_IDs, test_labels)
+validation_generator = DataGenerator(val_list_IDs, val_labels)
+
+# Load pre-trained ResNet50V2 model (excluding the top layer)
+base_model = ResNet50V2(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
+
+# Freeze the layers of the pre-trained model
+for layer in base_model.layers:
+    layer.trainable = False
+
+# Unfreezing some layers of the base model for fine-tuning
+for layer in base_model.layers[-30:]:  # Unfreeze last 30 layers
+    layer.trainable = True
+
+# Data Augmentation
+data_augmentation = Sequential([
+    RandomFlip('horizontal_and_vertical'),
+    RandomRotation(0.1),
+    RandomZoom(0.1),
+    RandomTranslation(height_factor=0.1, width_factor=0.1),
+    RandomHeight(0.1),
+    RandomWidth(0.1)
+])
+
+# Unfreezing some layers of the base model for fine-tuning
+for layer in base_model.layers[-30:]:  # Unfreeze last 30 layers
+    layer.trainable = True
+
+# Define the new top layers for embedding
+embedding_layer = tf.keras.Sequential([
+    tf.keras.layers.Dropout(0.5),
+    tf.keras.layers.BatchNormalization(),
+    tf.keras.layers.Dense(200, activation='relu'),
+    tf.keras.layers.Dropout(0.3),
+    tf.keras.layers.GlobalAveragePooling2D(),
+    tf.keras.layers.Dense(num_classes, activation='softmax')
+])
+
+# Define the model
+model = tf.keras.Sequential([
+    base_model,
+    data_augmentation,
+    embedding_layer,
+    Dense(num_classes, activation='softmax')  # This layer is for training purposes only
+])
+
+# Learning Rate Scheduling
+lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
+    initial_learning_rate=1e-3,
+    decay_steps=1000,
+    decay_rate=0.9)
+optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)
+
+# Callbacks
+checkpoint = ModelCheckpoint('best_model.h5', monitor='val_accuracy', save_best_only=True)
+def scheduler(epoch, lr):
+    if epoch < 10:
+        return lr
+    else:
+        return lr * tf.math.exp(-0.1)
+lr_scheduler = LearningRateScheduler(scheduler)
+
+# Define metrics
+top1 = tf.keras.metrics.TopKCategoricalAccuracy(k=1)
+
+# Compile the model with a different optimizer or learning rate
+model.compile(optimizer=Adam(learning_rate=1e-4),  # Adjusted learning rate
+              loss='categorical_crossentropy',
+              metrics=['accuracy'])
+
+# Train the model with callbacks and class weights if necessary
+class_weights = {i: 1.0 for i in range(num_classes)}  # Modify these weights if needed
+
+history = model.fit(training_generator,
+                    epochs=40,
+                    validation_data=validation_generator,
+                    callbacks=[EarlyStopping(verbose=1, patience=5), checkpoint, lr_scheduler],
+                    class_weight=class_weights)
+
+# Evaluate the model
+evaluation_results = model.evaluate(validation_generator)
+print(f"Validation Loss: {evaluation_results[0]}, Validation Accuracy: {evaluation_results[1]}")
+
+import tensorflow as tf
+import matplotlib.pyplot as plt
+from sklearn.metrics import roc_curve, auc
+from sklearn.metrics.pairwise import cosine_similarity
+
+# After training and evaluation, compute the average accuracy per class
+def average_accuracy_per_class(model, generator, num_classes):
+    # Initialize a list to store correct counts for each class
+    correct_counts = [0] * num_classes
+    total_counts = [0] * num_classes
+
+    # Loop through the batches in the generator
+    for images, labels in generator:
+        predictions = model.predict(images)
+        predicted_classes = tf.argmax(predictions, axis=1)
+        true_classes = tf.argmax(labels, axis=1)
+
+        # Update the correct count and total count for each class
+        for i in range(len(true_classes)):
+            true_class_index = true_classes[i]
+            total_counts[true_class_index] += 1
+            if predicted_classes[i] == true_class_index:
+                correct_counts[true_class_index] += 1
+
+    # Compute the average accuracy for each class
+    average_accuracies = [correct / total if total != 0 else 0 for correct, total in zip(correct_counts, total_counts)]
+
+    # Return the overall average accuracy across classes
+    return sum(average_accuracies) / len(average_accuracies)
+
+# Compute ROC curve and AUC for each class
+def roc_auc_per_class(model, generator, num_classes):
+    all_fpr = []
+    all_tpr = []
+    all_auc = []
+
+    for images, labels in generator:
+        predictions = model.predict(images)
+
+        # Compute ROC curve and AUC for each class
+        for i in range(num_classes):
+            try:
+                # Check if both positive and negative examples are present
+                if len(np.unique(labels[:, i])) > 1:
+                    fpr, tpr, _ = roc_curve(labels[:, i], predictions[:, i])
+                    roc_auc = auc(fpr, tpr)
+                else:
+                    # If only one class is present, assign arbitrary values
+                    fpr, tpr, roc_auc = [0], [0], 0.5
+
+                all_fpr.append(fpr)
+                all_tpr.append(tpr)
+                all_auc.append(roc_auc)
+            except Exception as e:
+                print(f"Error in computing ROC for class {i}: {e}")
+                fpr, tpr, roc_auc = [0], [0], 0.5  # Default values in case of an error
+                all_fpr.append(fpr)
+                all_tpr.append(tpr)
+                all_auc.append(roc_auc)
+
+    return all_fpr, all_tpr, all_auc
+
+# Compute average cosine similarity between predicted embeddings and true embeddings
+def average_cosine_similarity(model, generator):
+    cosine_similarities = []
+
+    for images, labels in generator:
+        predictions = model.predict(images)
+
+        # Ensure that labels are one-hot encoded
+        one_hot_labels = keras.utils.to_categorical(labels, num_classes=model.output_shape[-1])
+
+        # Compute cosine similarity for each pair of prediction and true label
+        for i in range(predictions.shape[0]):
+            sim = cosine_similarity([predictions[i]], [one_hot_labels[i]])[0][0]
+            cosine_similarities.append(sim)
+
+    return np.mean(cosine_similarities)
+
+# Then call this function as before
+train_avg_acc_per_class = average_accuracy_per_class(model, training_generator, num_classes)
+val_avg_acc_per_class = average_accuracy_per_class(model, validation_generator, num_classes)
+
+print("\nAverage Accuracy Per Class (Training): {:.2f}%".format(train_avg_acc_per_class * 100))
+print("Average Accuracy Per Class (Validation): {:.2f}%".format(val_avg_acc_per_class * 100))
+
+# Assess the performance on the train and validation sets
+train_evaluation = model.evaluate(training_generator)
+validation_evaluation = model.evaluate(validation_generator)
+
+# Unpack the evaluation metrics for both train and validation
+train_loss, train_acc = train_evaluation
+val_loss, val_acc = validation_evaluation
+
+# Displaying the performance metrics as percentages
+print('\nTraining Metrics:')
+print('Loss:', train_loss)
+print('Accuracy: {:.2f}%'.format(train_acc * 100))
+
+print('\nValidation Metrics:')
+print('Loss:', val_loss)
+print('Accuracy: {:.2f}%'.format(val_acc * 100))
+
+# Retrieve the history object from model training
+training_stats = history.history
+
+# Derive accuracy and loss metrics from the history
+train_acc_values = training_stats['accuracy']
+val_acc_values = training_stats['val_accuracy']
+train_loss_values = training_stats['loss']
+val_loss_values = training_stats['val_loss']
+
+# Visualize the training accuracy and loss
+plt.figure(figsize=(12, 4))
+
+# Accuracy subplot
+plt.subplot(1, 2, 1)
+plt.plot(train_acc_values, label='Training Accuracy')
+plt.plot(val_acc_values, label='Validation Accuracy')
+plt.xlabel('Epoch')
+plt.ylabel('Accuracy')
+plt.legend()
+plt.title('Accuracy for Training vs. Validation')
+
+# Loss subplot
+plt.subplot(1, 2, 2)
+plt.plot(train_loss_values, label='Training Loss')
+plt.plot(val_loss_values, label='Validation Loss')
+plt.xlabel('Epoch')
+plt.ylabel('Loss')
+plt.legend()
+plt.title('Loss for Training vs. Validation')
+
+plt.tight_layout()
+plt.show()
+
+# Compute ROC curves and plot them
+train_fpr, train_tpr, train_auc = roc_auc_per_class(model, training_generator, num_classes)
+val_fpr, val_tpr, val_auc = roc_auc_per_class(model, validation_generator, num_classes)
+
+import random
+
+def plot_subset_roc_curves(fpr, tpr, auc, num_classes, subset_size=10):
+    plt.figure(figsize=(8, 6))
+    plt.plot([0, 1], [0, 1], 'k--')
+
+    selected_classes = random.sample(range(num_classes), subset_size)
+    for i in selected_classes:
+        plt.plot(fpr[i], tpr[i], label=f'Class {i} (AUC = {auc[i]:.2f})')
+
+    plt.xlabel('False Positive Rate')
+    plt.ylabel('True Positive Rate')
+    plt.title('ROC Curve (Subset of Classes)')
+    plt.legend()
+    plt.show()
+
+# Plot for Training and Validation Set
+plot_subset_roc_curves(train_fpr, train_tpr, train_auc, num_classes=4000, subset_size=10)
+plot_subset_roc_curves(val_fpr, val_tpr, val_auc, num_classes=4000, subset_size=10)
+
+# Compute and print average cosine similarity
+train_avg_cosine_similarity = average_cosine_similarity(model, training_generator)
+val_avg_cosine_similarity = average_cosine_similarity(model, validation_generator)
+
+print("\nAverage Cosine Similarity (Training): {:.4f}".format(train_avg_cosine_similarity))
+print("Average Cosine Similarity (Validation): {:.4f}".format(val_avg_cosine_similarity))
+plt.show()
+
+# Save the model
+model.save_weights("final_weights.h5")
+model.save("final_model.h5")

anti_spoofing.py

@@ -0,0 +1,232 @@
+# Import all the libraries
+import cv2
+import dlib
+import numpy as np
+import os
+import time
+import mediapipe as mp
+from skimage import feature
+
+# I'm setting up the face and hand detectors here.
+class AntiSpoofingSystem:
+    def __init__(self):
+        self.detector = dlib.get_frontal_face_detector()
+        self.predictor = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat")
+
+        # Here I initialize MediaPipe for hand gesture detection.
+        self.mp_hands = mp.solutions.hands
+        self.hands = self.mp_hands.Hands(static_image_mode=False, max_num_hands=1, min_detection_confidence=0.7)
+
+
+        # This code is for Webcam if you have Jetson kit change value from 0 to 1.
+        self.cap = cv2.VideoCapture(0)
+        self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
+        self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)
+
+        # I create a directory to save the captured images if it doesn't exist.
+        self.save_directory = "Person"
+        if not os.path.exists(self.save_directory):
+            os.makedirs(self.save_directory)
+
+
+        # Iam loading the Pre-trained model to detect smartphones.
+        self.net_smartphone = cv2.dnn.readNet('yolov4.weights', 'PreTrained_yolov4.cfg')
+        with open('PreTrained_coco.names', 'r') as f:
+            self.classes_smartphone = f.read().strip().split('\n')
+
+
+        # Setting some thresholds for eye aspect ratio to detect blinks.
+        self.EAR_THRESHOLD = 0.2
+        self.BLINK_CONSEC_FRAMES = 4
+
+        # Initializing some variables to keep track of eye states and blink counts.
+        self.left_eye_state = False
+        self.right_eye_state = False
+        self.left_blink_counter = 0
+        self.right_blink_counter = 0
+
+        # Variables to manage smartphone detection.
+        self.smartphone_detected = False
+        self.smartphone_detection_frame_interval = 20
+        self.frame_count = 0
+
+        # New attributes for student data
+        self.student_id = None
+        self.student_name = None
+
+
+    # It is calculating the eye aspect ratio to detect blinks.
+    def calculate_ear(self, eye):
+        A = np.linalg.norm(eye[1] - eye[5])
+        B = np.linalg.norm(eye[2] - eye[4])
+        C = np.linalg.norm(eye[0] - eye[3])
+        return (A + B) / (2.0 * C)
+
+
+    # Analyzing the texture of the face to check for liveness.
+    def analyze_texture(self, face_region):
+        gray_face = cv2.cvtColor(face_region, cv2.COLOR_BGR2GRAY)
+        lbp = feature.local_binary_pattern(gray_face, P=8, R=1, method="uniform")
+        lbp_hist, _ = np.histogram(lbp.ravel(), bins=np.arange(0, 58), range=(0, 58))
+        lbp_hist = lbp_hist.astype("float")
+        lbp_hist /= (lbp_hist.sum() + 1e-5)
+        return np.sum(lbp_hist[:10]) > 0.3
+
+    # Detecting hand using MediaPipe.
+    def detect_hand_gesture(self, frame):
+        results = self.hands.process(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+        return results.multi_hand_landmarks is not None
+
+    # Detecting smartphones in the frame to prevent System Bypass.
+    def detect_smartphone(self, frame):
+        if self.frame_count % self.smartphone_detection_frame_interval == 0:
+            blob = cv2.dnn.blobFromImage(frame, 1 / 255.0, (224, 224), swapRB=True, crop=False)
+            self.net_smartphone.setInput(blob)
+            output_layers_names = self.net_smartphone.getUnconnectedOutLayersNames()
+            detections = self.net_smartphone.forward(output_layers_names)
+
+            for detection in detections:
+                for obj in detection:
+                    scores = obj[5:]
+                    class_id = np.argmax(scores)
+                    confidence = scores[class_id]
+                    if confidence > 0.3 and self.classes_smartphone[class_id] == 'cell phone':
+                        center_x = int(obj[0] * frame.shape[1])
+                        center_y = int(obj[1] * frame.shape[0])
+                        width = int(obj[2] * frame.shape[1])
+                        height = int(obj[3] * frame.shape[0])
+                        left = int(center_x - width / 2)
+                        top = int(center_y - height / 2)
+
+                        cv2.rectangle(frame, (left, top), (left + width, top + height), (0, 0, 255), 2)
+                        cv2.putText(frame, 'Smartphone Detected', (left, top - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
+                        
+                        self.smartphone_detected = True
+                        self.left_blink_counter = 0
+                        self.right_blink_counter = 0
+                        return
+
+        self.frame_count += 1
+        self.smartphone_detected = False
+
+    # Checking if the user blinked to confirm their presence.
+    def detect_blink(self, left_ear, right_ear):
+        if self.smartphone_detected:
+            self.left_eye_state = False
+            self.right_eye_state = False
+            self.left_blink_counter = 0
+            self.right_blink_counter = 0
+            return False
+
+        # Incrementing blink counter if a blink is detected.
+        if left_ear < self.EAR_THRESHOLD:
+            if not self.left_eye_state:
+                self.left_eye_state = True
+        else:
+            if self.left_eye_state:
+                self.left_eye_state = False
+                self.left_blink_counter += 1
+
+        if right_ear < self.EAR_THRESHOLD:
+            if not self.right_eye_state:
+                self.right_eye_state = True
+        else:
+            if self.right_eye_state:
+                self.right_eye_state = False
+                self.right_blink_counter += 1
+
+
+        # Resetting blink counters after a successful blink detection.
+        if self.left_blink_counter > 0 and self.right_blink_counter > 0:
+            self.left_blink_counter = 0
+            self.right_blink_counter = 0
+            return True
+        else:
+            return False
+
+    # Main loop to process the video feed.
+    def run(self, update_frame_callback=None):
+        blink_count = 0
+        hand_gesture_detected = False
+        image_captured = False
+        last_event_time = time.time()
+        event_timeout = 60
+        message_displayed = False
+
+        while True:
+            ret, frame = self.cap.read()
+            if not ret:
+                break
+            
+            # Detecting smartphones in the frame.   
+            self.detect_smartphone(frame)
+
+            # Displaying a warning if a smartphone is detected.
+            if self.smartphone_detected:
+                cv2.putText(frame, "Mobile phone detected, can't record attendance", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+                blink_count = 0
+
+            # Processing each frame to detect faces, blinks, and hand gestures.
+            if not self.smartphone_detected:
+                gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+                faces = self.detector(gray)
+
+                for face in faces:
+                    landmarks = self.predictor(gray, face)
+                    leftEye = np.array([(landmarks.part(n).x, landmarks.part(n).y) for n in range(36, 42)])
+                    rightEye = np.array([(landmarks.part(n).x, landmarks.part(n).y) for n in range(42, 48)])
+
+                    ear_left = self.calculate_ear(leftEye)
+                    ear_right = self.calculate_ear(rightEye)
+
+                    if self.detect_blink(ear_left, ear_right):
+                        blink_count += 1
+
+                    # Prionting and Incrementing blink Count
+                    cv2.putText(frame, f"Blink Count: {blink_count}", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
+
+                    hand_gesture_detected = self.detect_hand_gesture(frame)
+
+                    # Indicating when a hand gesture is detected.
+                    if hand_gesture_detected:
+                        cv2.putText(frame, "Hand Gesture Detected", (10, 100), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
+
+                    (x, y, w, h) = (face.left(), face.top(), face.width(), face.height())
+                    expanded_region = frame[max(y - h // 2, 0):min(y + 3 * h // 2, frame.shape[0]),
+                                            max(x - w // 2, 0):min(x + 3 * w // 2, frame.shape[1])]
+
+                    # Checking if the conditions are met to capture the image.
+                    if blink_count >= 5 and hand_gesture_detected and self.analyze_texture(expanded_region) and not message_displayed:
+                        cv2.putText(frame, "Please hold still for 2 seconds...", (10, 150), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+                        cv2.imshow("Frame", frame)
+                        cv2.waitKey(1)
+                        time.sleep(2)
+                        message_displayed = True
+
+                    if message_displayed and not image_captured:
+                        timestamp = int(time.time())
+                        picture_name = f"{self.student_id}_{timestamp}.jpg"
+                        cv2.imwrite(os.path.join(self.save_directory, picture_name), expanded_region)
+                        image_captured = True
+
+            if update_frame_callback:
+                update_frame_callback(frame)
+
+            cv2.imshow("Frame", frame)
+            if image_captured or (time.time() - last_event_time > event_timeout and not hand_gesture_detected):
+                break
+            if cv2.waitKey(1) & 0xFF == ord('q'):
+                break
+
+        self.cap.release()
+        cv2.destroyAllWindows()
+
+        #If person if real and did all the required features then his attendance will be marked if not then it will print no person detected.
+        if image_captured:
+            print(f"Person detected. Face image captured and saved as {picture_name}.")
+        elif not hand_gesture_detected:
+            print("No real person detected")
+
+if __name__ == "__main__":
+    anti_spoofing_system = AntiSpoofingSystem()
+    anti_spoofing_system.run()

appm.py

@@ -0,0 +1,232 @@
+import customtkinter as ctk
+import cv2
+import tkinter as tk
+from PIL import Image, ImageTk
+import subprocess
+from customtkinter import FontManager
+import os
+
+# Import your AntiSpoofingSystem here
+from anti_spoofing import AntiSpoofingSystem
+
+# Import TensorFlow and other dependencies if needed for the face recognition part
+import tensorflow as tf
+import numpy as np
+from scipy.spatial.distance import cosine
+
+################### INTERFACE ###################
+
+# New Color Scheme
+primary_color = "#007BFF"  # Blue
+secondary_color = "#FFFFFF"  # White
+text_color = "#333333"  # Dark text for readability
+
+# Custom Font
+FontManager.load_font("Roboto-Regular.ttf")  # Use Roboto font
+
+# Instantiate AntiSpoofingSystem
+anti_spoofing_system = AntiSpoofingSystem()
+
+# Button dimensions and styles
+button_width, button_height, font_size, font_size_total = 160, 40, 16, 20
+corner_radius, border_color, border_width = 8, primary_color, 2
+
+def create_button(parent, text, command):
+    # Redesigned Button Style
+    return ctk.CTkButton(parent, text=text, command=command, fg_color=primary_color,
+                         text_color=secondary_color, hover_color=text_color, font=("Roboto", font_size),
+                         width=button_width, height=button_height,
+                         corner_radius=corner_radius, border_color=border_color, border_width=border_width)
+
+# Directory for saving registered user images
+save_directory = "Person"
+
+if not os.path.exists(save_directory):
+    os.makedirs(save_directory)
+
+def register_interface():
+    global buttonRegister, buttonCheckIn
+
+    # Hide existing buttons
+    buttonRegister.pack_forget()
+    buttonCheckIn.pack_forget()
+   
+
+    # Call the run method of anti-spoofing_system to capture an image
+    frame = anti_spoofing_system.run()
+
+    if frame is not None:
+        # Save the captured image for registration
+        user_id = register_fill.get()
+        image_filename = os.path.join(save_directory, f"{user_id}.png")
+        cv2.imwrite(image_filename, frame)
+        
+        # Reset the image_captured flag for future registrations
+        anti_spoofing_system.image_captured = False
+
+        # Update UI to indicate successful registration
+        status_label.configure(text=f"User {user_id} registered successfully.")
+
+        # Reset UI elements as needed
+        register_fill.delete(0, tk.END)  # Clear the entry field
+        register_fill.pack_forget()
+        buttonRegister.pack_forget()
+        main_interface()  # Return to the main interface
+
+def main_interface():
+    global buttonRegister, buttonCheckIn, buttonBack
+
+    buttonRegister = create_button(
+        button_frame, "Register", register_interface)
+    buttonRegister.pack(side="left", padx=10)
+
+    buttonCheckIn = create_button(
+        button_frame, "Check Database", check_in)
+    buttonCheckIn.pack(side="left", padx=10)
+
+
+def update_total_students_label():
+    total_students_label.configure(
+        text=f"Total Students: {len(checked_in_students)}")
+
+def back():
+    subprocess.Popen(["python", "app.py"])
+    app.quit()
+
+    ################### VIDEO AND ANTI-SPOOFING ###################
+def update_frame():
+    global none_spoofed_image
+
+    # Call the run method of anti-spoofing_system
+    frame = anti_spoofing_system.run()
+
+    if frame is not None:
+        # Convert the frame to PhotoImage
+        cv2image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA)
+        img = Image.fromarray(cv2image)
+        imgtk = ImageTk.PhotoImage(image=img)
+        video_label.imgtk = imgtk
+        video_label.configure(image=imgtk)
+
+    video_label.after(10, update_frame)  # Continue updating the frame
+
+################### SUPERVISED MODEL ###################
+# Face recognition model and user embeddings
+RECOGNITION_THRESHOLD = 0.3
+embedding_model = tf.keras.models.load_model('best_model.h5')
+user_embeddings = {}
+
+def preprocess_image(image):
+    image = cv2.resize(image, (375, 375))  # Resize image to the expected input size
+    image = tf.keras.applications.resnet50.preprocess_input(image)  # Adjust if using a different model
+    return np.expand_dims(image, axis=0)
+
+
+def generate_embedding(image):
+    preprocessed_image = preprocess_image(image)
+    return embedding_model.predict(preprocessed_image)[0]
+
+def register_user(user_id):
+    global status_label, buttonRegister, register_fill
+
+    try:
+        # Check if the anti-spoofing image has been captured
+        if not anti_spoofing_system.image_captured:
+            status_label.configure(text="Please complete the anti-spoofing.")
+            return
+
+        # Retrieve the captured image
+        frame = anti_spoofing_system.get_captured_image()
+
+        # Reset the image_captured flag for future registrations
+        anti_spoofing_system.image_captured = False
+
+        # Generate an embedding from the captured frame
+        embedding = generate_embedding(frame)
+
+        # Store the embedding with the user ID
+        user_embeddings[user_id] = embedding
+
+        # Update UI to indicate successful registration
+        status_label.configure(text=f"User {user_id} registered successfully.")
+
+        # Reset UI elements as needed
+        register_fill.delete(0, tk.END)  # Clear the entry field
+        register_fill.pack_forget()
+        buttonRegister.pack_forget()
+        main_interface()  # Return to the main interface
+
+    except Exception as e:
+        status_label.configure(text=f"Error during registration: {str(e)}")
+
+def check_in():
+    global status_label, checked_in_students
+
+    try:
+        frame = anti_spoofing_system.access_verified_image()
+
+        if frame is None:
+            status_label.configure(text="Please complete the anti-spoofing check first.")
+            return
+
+        new_embedding = generate_embedding(frame)
+        min_distance = float('inf')
+        recognized_user_id = "Unknown"
+
+        # Load and compare with each user image in the Persons directory
+        for filename in os.listdir(save_directory):
+            if filename.endswith(".png"):
+                user_id = filename.split('.')[0]
+                user_image = cv2.imread(os.path.join(save_directory, filename))
+                embedding = generate_embedding(user_image)
+                distance = cosine(new_embedding, embedding)
+                if distance < min_distance:
+                    min_distance = distance
+                    recognized_user_id = user_id
+
+        if min_distance <= RECOGNITION_THRESHOLD:
+            checked_in_students.add(recognized_user_id)
+            status_label.configure(text=f"Checked in: {recognized_user_id}")
+        else:
+            status_label.configure(text="User does not exist in Person folder.")
+
+    except Exception as e:
+        status_label.configure(text=f"Error during check-in: {str(e)}")
+
+################### APP IMPLEMENTATION ###################
+app = ctk.CTk()
+app.title("Face Recognition Attendance System")
+app.geometry("1440x810")
+ctk.set_appearance_mode("light")
+
+# Video and Anti-Spoofing Setup
+cap = cv2.VideoCapture(0)
+main_frame = ctk.CTkFrame(app, fg_color=secondary_color)
+main_frame.pack(expand=True, fill='both')
+video_label = tk.Label(main_frame, width=930, height=650)
+video_label.grid(row=0, column=0, padx=10, columnspan=2)
+
+# TOTAL STUDENT
+checked_in_students = set()
+
+total_students_label = ctk.CTkLabel(
+    main_frame, text=f"Total Students: {len(checked_in_students)}", font=("Roboto", font_size_total))
+total_students_label.grid(row=0, column=2, sticky="nw", padx=10)
+
+verified_label = ctk.CTkLabel(
+    main_frame, text="AntiSpoofed: False", font=("Roboto", font_size_total))
+verified_label.grid(row=0, column=2, sticky="sw", padx=10)
+
+# STATUS
+status_label = ctk.CTkLabel(main_frame, text="", font=("Roboto", font_size), fg_color=secondary_color, text_color=text_color)
+status_label.grid(row=1, column=0, padx=10, columnspan=2)
+
+# BUTTON FRAME
+button_frame = ctk.CTkFrame(main_frame, fg_color=secondary_color)
+button_frame.grid(row=2, column=0, columnspan=3, pady=20)
+main_interface()
+
+################### LOOP ###################
+update_frame()
+app.mainloop()
+cap.release()

best_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a26ab2737b772bc23a8df009457f65bae644cbe946fd7b8049201cec4bd3a050
+size 103070256

self_supervised.py

@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+# Import necessary libraries
+import os
+import random
+import gdown
+import tensorflow as tf
+from tensorflow.keras import layers, Model, metrics, optimizers
+from tensorflow.keras.applications import resnet
+import matplotlib.pyplot as plt
+from tensorflow.keras.callbacks import EarlyStopping
+
+# URL for the dataset and directory for downloading
+data_url = "https://drive.google.com/file/d/13hSwP2O4pd3NVVnWj2Fcah_r-jkf8uiv/view?usp=drive_link"
+download_dir = "./classification_data/"
+
+# Define the target shape for image resizing
+image_shape = (200, 200)
+
+# Function to load and process a single image
+def load_and_process_image(file_path):
+    image_data = tf.io.read_file(file_path)
+    image = tf.image.decode_jpeg(image_data, channels=3)
+    image = tf.image.convert_image_dtype(image, tf.float32)
+    return tf.image.resize(image, image_shape)
+
+# Function to process image triplets (anchor, positive, negative)
+def process_triplets(anchor, pos, neg):
+    return (load_and_process_image(anchor),
+            load_and_process_image(pos),
+            load_and_process_image(neg))
+
+# Function to create a dataset from a directory
+def create_dataset(directory):
+    anchor_list, positive_list, negative_list = [], [], []
+
+    for category in os.listdir(directory):
+        category_path = os.path.join(directory, category)
+        images = os.listdir(category_path)
+
+        # Loop through each image, creating triplets
+        for anchor_img in images:
+            anchor_img_path = os.path.join(category_path, anchor_img)
+            anchor_list.append(anchor_img_path)
+
+            positive_img = random.choice(images)
+            positive_list.append(os.path.join(category_path, positive_img))
+
+            different_category = random.choice([c for c in os.listdir(directory) if c != category])
+            negative_img = random.choice(os.listdir(os.path.join(directory, different_category)))
+            negative_list.append(os.path.join(directory, different_category, negative_img))
+
+    # Create and return the dataset
+    dataset = tf.data.Dataset.zip((tf.data.Dataset.from_tensor_slices(anchor_list),
+                                   tf.data.Dataset.from_tensor_slices(positive_list),
+                                   tf.data.Dataset.from_tensor_slices(negative_list)))
+    dataset = dataset.shuffle(1024).map(process_triplets).batch(64).prefetch(8)
+    return dataset
+
+# Create training and validation datasets
+train_data = create_dataset(download_dir + "train_data/")
+val_data = create_dataset(download_dir + "val_data/")
+
+# Build the base CNN model using ResNet50
+base_model = resnet.ResNet50(weights="imagenet", input_shape=image_shape + (3,), include_top=False)
+flattened_output = layers.Flatten()(base_model.output)
+dense_layer1 = layers.Dense(512, activation="relu")(flattened_output)
+normalized1 = layers.BatchNormalization()(dense_layer1)
+dense_layer2 = layers.Dense(256, activation="relu")(normalized1)
+normalized2 = layers.BatchNormalization()(dense_layer2)
+final_output = layers.Dense(256)(normalized2)
+
+embedding_model = Model(inputs=base_model.input, outputs=final_output, name="Image_Embedding")
+
+# Make specific layers trainable
+for layer in base_model.layers:
+    layer.trainable = layer.name >= "conv5_block1_out"
+
+# Define a custom Distance Layer for the Siamese Network
+class DistanceLayer(layers.Layer):
+    def call(self, anchor_embedding, positive_embedding, negative_embedding):
+        distance_pos = tf.reduce_sum(tf.square(anchor_embedding - positive_embedding), -1)
+        distance_neg = tf.reduce_sum(tf.square(anchor_embedding - negative_embedding), -1)
+        return distance_pos, distance_neg
+
+# Inputs for the Siamese Network
+anchor_input = layers.Input(name="anchor_input", shape=image_shape + (3,))
+positive_input = layers.Input(name="positive_input", shape=image_shape + (3,))
+negative_input = layers.Input(name="negative_input", shape=image_shape + (3,))
+
+# Build the Siamese Network
+siamese_network = Model(inputs=[anchor_input, positive_input, negative_input],
+                        outputs=DistanceLayer()(
+                            embedding_model(resnet.preprocess_input(anchor_input)),
+                            embedding_model(resnet.preprocess_input(positive_input)),
+                            embedding_model(resnet.preprocess_input(negative_input))
+                        ))
+
+# Custom Siamese Model class
+class CustomSiameseModel(Model):
+    def __init__(self, network, margin=0.5):
+        super().__init__()
+        self.network = network
+        self.margin = margin
+        self.loss_metric = metrics.Mean(name="loss")
+        self.accuracy_metric = metrics.Mean(name="accuracy")
+
+    def call(self, inputs):
+        return self.network(inputs)
+
+    def train_step(self, data):
+        with tf.GradientTape() as tape:
+            loss, accuracy = self.compute_loss_and_accuracy(data)
+        gradients = tape.gradient(loss, self.network.trainable_weights)
+        self.optimizer.apply_gradients(zip(gradients, self.network.trainable_weights))
+        self.loss_metric.update_state(loss)
+        self.accuracy_metric.update_state(accuracy)
+        return {"loss": self.loss_metric.result(), "accuracy": self.accuracy_metric.result()}
+
+    def test_step(self, data):
+        loss, accuracy = self.compute_loss_and_accuracy(data)
+        self.loss_metric.update_state(loss)
+        self.accuracy_metric.update_state(accuracy)
+        return {"loss": self.loss_metric.result(), "accuracy": self.accuracy_metric.result()}
+
+    def compute_loss_and_accuracy(self, data):
+        ap_dist, an_dist = self.network(data)
+        loss = tf.maximum(ap_dist - an_dist + self.margin, 0.0)
+
+        # Calculate accuracy as top-1 accuracy
+        accuracy = tf.reduce_mean(tf.cast(tf.less(ap_dist, an_dist), tf.float32))
+        return loss, accuracy
+
+    @property
+    def metrics(self):
+        return [self.loss_metric, self.accuracy_metric]
+
+# Compile and train the Siamese model
+siamese_model = CustomSiameseModel(siamese_network)
+siamese_model.compile(optimizer=optimizers.Adadelta())
+
+# Callback for early stopping
+early_stopping_callback = EarlyStopping(monitor='val_accuracy', patience=3, restore_best_weights=True)
+
+# Training the model
+history = siamese_model.fit(train_data, epochs=30, validation_data=val_data)
+
+# Save model weights
+embedding_model.save_weights("siamese_model_weights.h5")
+
+# Plot training history (loss and accuracy)
+plt.figure(figsize=(12, 4))
+plt.subplot(1, 2, 1)
+plt.plot(history.history['loss'], label='Train Loss')
+plt.plot(history.history['val_loss'], label='Validation Loss')
+plt.title('Loss Over Epochs')
+plt.legend()
+
+plt.subplot(1, 2, 2)
+plt.plot(history.history['accuracy'], label='Train Accuracy')
+plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
+plt.title('Accuracy Over Epochs')
+plt.legend()
+plt.show()
+
+# Compute and display cosine similarity
+cosine_similarity = metrics.CosineSimilarity()
+sample = next(iter(train_data))
+anchor, positive, negative = sample
+anchor_embedding, positive_embedding, negative_embedding = (
+    embedding_model(resnet.preprocess_input(anchor)),
+    embedding_model(resnet.preprocess_input(positive)),
+    embedding_model(resnet.preprocess_input(negative)),
+)
+positive_similarity = cosine_similarity(anchor_embedding, positive_embedding).numpy()
+negative_similarity = cosine_similarity(anchor_embedding, negative_embedding).numpy()
+print("Positive similarity:", positive_similarity)
+print("Negative similarity", negative_similarity)
+
+# Compute ROC and AUC
+actual_labels = [1] * positive_similarity.size + [0] * negative_similarity.size
+import numpy as np
+predicted_scores = np.vstack([positive_similarity, negative_similarity]).squeeze()
+from sklearn.metrics import roc_curve, auc
+fpr, tpr, thresholds = roc_curve(actual_labels, predicted_scores)
+roc_auc = auc(fpr, tpr)
+
+# Plot ROC Curve
+plt.figure(figsize=(8, 6))
+plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)
+plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
+plt.xlim([0.0, 1.0])
+plt.ylim([0.0, 1.05])
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('Receiver Operating Characteristic')
+plt.legend(loc="lower right")
+plt.show()
+
+# Save the Siamese model as a TensorFlow SavedModel
+embedding_model.save("embedding_model.h5")

shape_predictor_68_face_landmarks.dat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fbdc2cb80eb9aa7a758672cbfdda32ba6300efe9b6e6c7a299ff7e736b11b92f
+size 99693937

siamese_network (2).h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f78bff0c9f739593355ef9231c9e96294586447b2b50f38c055ae36de69e5200
+size 91926360

yolov4.weights

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8a4f6c62188738d86dc6898d82724ec0964d0eb9d2ae0f0a9d53d65d108d562
+size 257717640