Upload 4 files

ModelTransferLearning.py

@@ -0,0 +1,99 @@
+import numpy as np
+import pandas as pd
+import csv
+import tensorflow as tf
+from sklearn.model_selection import train_test_split
+import cv2
+from pathlib import Path
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense, Flatten, Input
+from tensorflow.keras.optimizers import Adam
+from keras.applications import vgg16
+
+def ModelFineTuning():
+    # Define the path to your dataset
+    data_dir = Path('Dataset')
+    image_size = (224, 224)  # VGGFace model expects 224x224 images
+
+    # Initialize dictionaries
+    candidates_dict = {}
+    labels_dict = {}
+
+    # Get all class folder names
+    class_folders = [folder.name for folder in data_dir.iterdir() if folder.is_dir()]
+    total_classes = len(class_folders)
+
+    # Assign labels to each class
+    for idx, class_name in enumerate(class_folders):
+        candidates_dict[class_name] = list(data_dir.glob(f'{class_name}/*'))
+        labels_dict[class_name] = idx
+
+    df = pd.DataFrame(list(labels_dict.items()), columns=['Candidate Name', 'Label'])
+    df.to_csv("candidate_labels.csv", index=False)
+
+    # Print the results
+    print('Images Dictionary:')
+    print(candidates_dict)
+    print('\nLabels Dictionary:')
+    print(labels_dict)
+
+    X, y = [], []
+    if len(candidates_dict.items()) == 0:
+        return False
+    for candidate_name, faces in candidates_dict.items():
+        for image in faces:
+            img = cv2.imread(str(image))
+            resized_img = cv2.resize(img, image_size)
+            X.append(resized_img)
+            y.append(labels_dict[candidate_name])
+
+    print(len(X))
+
+    X = np.array(X)
+    y = np.array(y)
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
+
+    X_train_scaled = X_train / 255.0
+    X_test_scaled = X_test / 255.0
+
+    # Convert labels to one-hot encoding
+    y_train = tf.keras.utils.to_categorical(y_train, num_classes=total_classes)
+    y_test = tf.keras.utils.to_categorical(y_test, num_classes=total_classes)
+
+    # Load the pre-trained VGGFace model
+    base_model = vgg16.VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
+
+    # Ensure the base model layers are not trainable
+    for layer in base_model.layers:
+        layer.trainable = False
+
+    # Create a Sequential model and add layers
+    model = Sequential()
+    model.add(Input(shape=(224, 224, 3)))
+    model.add(base_model)
+    model.add(Flatten())
+    model.add(Dense(1024, activation='relu'))
+    model.add(Dense(512, activation='relu'))
+    model.add(Dense(total_classes, activation='softmax'))
+
+    # Compile the model
+    model.compile(optimizer=Adam(learning_rate=0.0001), loss='categorical_crossentropy', metrics=['accuracy'])
+
+    # Train the model
+    history = model.fit(
+        X_train_scaled, y_train,
+        validation_data=(X_test_scaled, y_test),
+        epochs=10,  # Adjust the number of epochs based on your needs
+        batch_size=32
+    )
+
+    # Evaluate the model
+    loss, accuracy = model.evaluate(X_test_scaled, y_test)
+    print(f"Test accuracy: {accuracy * 100:.2f}%")
+
+    # Save the fine-tuned model
+    model.save('fine_tuned_VGG16_model.h5')
+    return True
+
+# ModelFineTuning()  # Uncomment this line to run the training

PredictFace.py

@@ -0,0 +1,42 @@
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+import cv2
+from pathlib import Path
+from datetime import datetime
+from tensorflow.keras.models import load_model
+
+
+# Function to preprocess the image
+def preprocess_image(image_path, target_size=(224, 224)):
+    img = cv2.imread(image_path)
+    img = cv2.resize(img, target_size)
+    img = img / 255.0
+    img = np.expand_dims(img, axis=0)
+    return img
+
+# Function to predict the label of the image
+def predict_candidate(image_path):
+
+    model = load_model('fine_tuned_VGG16_model.h5')
+
+    df = pd.read_csv('candidate_labels.csv')
+    labels_dict = df.set_index('Label')['Candidate Name'].to_dict()
+
+    if image_path == '':
+        image_path = 'Dataset/test_img.jpg' 
+
+    img = preprocess_image(image_path)
+    prediction = model.predict(img)
+    predicted_class = np.argmax(prediction, axis=1)[0]
+    predicted_label = labels_dict[predicted_class]
+
+    # Get the current timestamp in 12-hour format without seconds
+    timestamp = datetime.now().strftime('%Y-%m-%d %I:%M %p')
+    # Save to CSV
+    attendance_record = pd.DataFrame([[timestamp, predicted_label]], columns=['Timestamp', 'Student ID Number'])
+    attendance_record.to_csv('Attendance_Record.csv', mode='a', header=False, index=False)
+
+    print("Label is", predicted_label)
+    return predicted_label
+

config.py

@@ -0,0 +1,6 @@
+# config.py
+import os
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+TF_OPS_PATH = os.path.join(BASE_DIR, 'path', 'to', 'tensorflow', 'python', 'ops')
+

trial1.py

@@ -0,0 +1,243 @@
+from flask import Flask, render_template, request, jsonify
+import os
+import base64
+import numpy as np
+import cv2
+import tensorflow as tf
+import csv
+import config
+from ModelTransferLearning import ModelFineTuning
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+import base64
+from io import BytesIO
+from PIL import Image
+from PredictFace import preprocess_image, predict_candidate
+
+app = Flask(__name__)
+
+# Load the Caffe model
+net = cv2.dnn.readNetFromCaffe('models/deploy.prototxt', 'models/res10_300x300_ssd_iter_140000.caffemodel')
+
+###
+def save_att_photos(images):
+    output_folder = 'AttendanceCapture'
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+        print(f"Created directory: {output_folder}")
+    else:
+        print(f"Directory already exists: {output_folder}")
+
+    count = 0
+    for i, image_data in enumerate(images):
+        try:
+            print(f"Processing image {i + 1}")
+            image_data = base64.b64decode(image_data.split(',')[1])
+            image_np = np.frombuffer(image_data, np.uint8)
+            image = cv2.imdecode(image_np, cv2.IMREAD_COLOR)
+            if image is None:
+                print(f"Failed to decode image {i + 1}")
+                continue
+
+            (h, w) = image.shape[:2]
+            blob = cv2.dnn.blobFromImage(image, 1.0, (300, 300), [104, 117, 123], False, False)
+            net.setInput(blob)
+            detections = net.forward()
+
+            for j in range(detections.shape[2]):
+                confidence = detections[0, 0, j, 2]
+                if confidence > 0.7:
+                    box = detections[0, 0, j, 3:7] * np.array([w, h, w, h])
+                    (startX, startY, endX, endY) = box.astype("int")
+                    face = image[startY:endY, startX:endX]
+                    cv2.rectangle(image, (startX, startY), (endX, endY), (0, 255, 0), 2)
+
+                    count += 1
+                    face_filename = os.path.join(output_folder, f'face_{count}.jpg')
+                    cv2.imwrite(face_filename, face)
+                    print(f'Saved {face_filename}')
+                    break
+        except Exception as e:
+            print(f"Error processing image {i + 1}: {e}")
+            continue
+
+    print(f"Total faces saved: {count}")
+    # save_to_csv(student_id, name)
+    return count >= 1
+###
+
+def save_photos(student_id, images):
+    output_folder = f'Dataset/{student_id}'
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+        print(f"Created directory: {output_folder}")
+    else:
+        print(f"Directory already exists: {output_folder}")
+
+    count = 0
+    for i, image_data in enumerate(images):
+        try:
+            print(f"Processing image {i + 1}")
+            image_data = base64.b64decode(image_data.split(',')[1])
+            image_np = np.frombuffer(image_data, np.uint8)
+            image = cv2.imdecode(image_np, cv2.IMREAD_COLOR)
+            if image is None:
+                print(f"Failed to decode image {i + 1}")
+                continue
+
+            (h, w) = image.shape[:2]
+            blob = cv2.dnn.blobFromImage(image, 1.0, (300, 300), [104, 117, 123], False, False)
+            net.setInput(blob)
+            detections = net.forward()
+
+            for j in range(detections.shape[2]):
+                confidence = detections[0, 0, j, 2]
+                if confidence > 0.7:
+                    box = detections[0, 0, j, 3:7] * np.array([w, h, w, h])
+                    (startX, startY, endX, endY) = box.astype("int")
+                    face = image[startY:endY, startX:endX]
+                    cv2.rectangle(image, (startX, startY), (endX, endY), (0, 255, 0), 2)
+
+                    count += 1
+                    face_filename = os.path.join(output_folder, f'face_{count}.jpg')
+                    cv2.imwrite(face_filename, face)
+                    print(f'Saved {face_filename}')
+                    break
+        except Exception as e:
+            print(f"Error processing image {i + 1}: {e}")
+            continue
+
+    print(f"Total faces saved: {count}")
+    # save_to_csv(student_id, name)
+    return count >= 20
+
+
+@app.route('/start_capture', methods=['POST'])
+def start_capture():
+    data = request.get_json()
+    student_id = data.get('student_id')
+    images = data.get('images')
+
+    if not student_id or not images:
+        return jsonify({'success': False, 'message': 'Invalid data'})
+
+    try:
+        if save_photos(student_id, images):
+            return jsonify({'success': True, 'message': 'Images saved successfully'})
+        else:
+            return jsonify({'success': False, 'message': 'Failed to save sufficient images'})
+
+    except Exception as e:
+        print(f'Error: {e}')
+        return jsonify({'success': False, 'message': 'Failed to save images'})
+    
+
+
+@app.route('/model_training', methods=['POST'])
+def model_training():
+    success = ModelFineTuning()
+    if success:
+        return jsonify(success=True, message="Model training completed successfully.")
+    else:
+        return jsonify(success=False, message="Model training failed.")
+    
+
+###
+@app.route('/take_photo', methods=['POST'])
+def take_photo():
+    data = request.get_json()
+    # student_id = data.get('student_id')
+    images = data.get('images')
+
+    try:
+        if save_att_photos(images):
+            return jsonify({'success': True, 'message': 'Image saved successfully'})
+        else:
+            return jsonify({'success': False, 'message': 'Failed to save image'})
+
+    except Exception as e:
+        print(f'Error: {e}')
+        return jsonify({'success': False, 'message': 'Failed to save image'})
+
+
+@app.route('/face_prediction', methods=['POST'])
+def face_prediction():
+    image_path = 'AttendanceCapture/face_1.jpg'
+    predicted_label = predict_candidate(image_path)
+    # success = predict_candidate(image_path)
+    if predicted_label:
+        return jsonify(success=True, predicted_label = predicted_label)
+    else:
+        return jsonify(success=False, message="Attendance failed")
+    
+###
+
+
+
+@app.route('/check_student_id', methods=['GET'])
+def check_student_id():
+    student_id = request.args.get('student_id')
+    directory_exists = os.path.exists(f'Dataset/{student_id}')
+    return jsonify({"directory_exists": directory_exists})
+
+
+
+@app.route("/register", methods=["POST", "GET"])
+def register():
+    if request.method == "POST":
+        name = request.form["name"]
+        student_id = request.form["student_id"]
+        if os.path.exists(f'Dataset/{student_id}'):
+            return jsonify({"success": False, "message": "Student is already registered."})
+        else:
+            return jsonify({"success": True, "student_id": student_id})
+    return render_template("register.html")
+
+
+
+@app.route('/capture')
+def capture_photos():
+    student_id = request.args.get('student_id')
+    # name = request.args.get('name')
+    print(f"Capturing photos for student_id: {student_id}")
+    return render_template("capture_photos.html", student_id=student_id)
+
+
+
+@app.route('/attendance')
+def attendance():
+    return render_template("attendance.html")
+
+
+
+@app.route('/')
+def home():
+    return render_template("index.html")
+
+
+# if __name__ == "__main__":
+#     app.run(debug=True)
+
+
+class TrainingHandler(FileSystemEventHandler):
+    def on_modified(self, event):
+        print(f'File changed: {event.src_path}')
+        if 'custom_gradient.py' in event.src_path:
+            print("Restarting training...")
+            ModelFineTuning()
+
+if __name__ == "__main__":
+
+    path_to_watch = os.environ.get('TF_OPS_PATH', 'C:\\Users\\Shruti Sundaram\\AppData\\Local\\Programs\\Python\\Python310\\Lib\\site-packages\\tensorflow\\python\\ops')
+    # path_to_watch = config.TF_OPS_PATH
+    event_handler = TrainingHandler()
+    observer = Observer()
+    observer.schedule(event_handler, path=path_to_watch, recursive=False)
+    observer.start()
+
+    try:
+        print("Starting initial training...")
+        app.run(debug=True)
+    except KeyboardInterrupt:
+        observer.stop()
+    observer.join()