Upload 18 files

Attendance.csv

@@ -0,0 +1,19 @@
+Name,Arrive_Time,Date,Late_penalty
+,,,
+Elon Musk,18:54:00,4/5/2023,-5
+Bill Gates,21:00:34,4/25/2023,-5
+Jeff Bezos,21:02:35,4/25/2023,-5
+ruth,19:58:52,4/26/2023,-5
+Abdul,15:42:55,5/3/2023,-5
+Bill Gates,15:25:16,5/6/2023,-2
+Mark Zuckerberg,15:45:01,5/6/2023,-2
+Ssembuya Abdurahumani,15:45:14,5/6/2023,-2
+Ruth Oteng,12:00:39,5/8/2023,-2
+
+Ssembuya Abdurahumani,10:09:42,2023/05/10,-2
+Ruth Oteng,12:50:42,2023/05/11,-2
+Ruth,13:04:57,2023/05/11,-2
+Ruth Oteng,15:37:23,2023/05/15,-2
+Ssembuya Abdurahumani,15:38:04,2023/05/15,-2
+Ruth,15:50:56,2023/05/15,-2
+Mark Zuckerberg,15:53:13,2023/05/15,-2

Preparing_local.py

@@ -0,0 +1,101 @@
+import cv2
+import face_recognition
+import os
+import time
+import pandas as pd
+import streamlit as st
+
+# Declaring variables
+path = "db"
+scale = 2
+
+def late_penalty(arrive_time):
+    penalty = 0
+    if int(arrive_time[0:2])> 9:
+        penalty = -2
+    return penalty
+
+def markattendance(person_name, attendance_file):
+
+    with open(attendance_file.name,'r+') as f:
+        lines = f.readlines()
+        name_list=[]
+        now = time.localtime()
+        date = time.strftime("%Y/%m/%d", now)
+
+        for line in lines:
+            entry = line.split(',')
+            if len(entry)>1:
+                if entry[2] == date:
+                    name_list.append(entry[0])
+        
+        if person_name not in name_list:
+            arrive_time = time.strftime("%H:%M:%S", now)
+            penalty = late_penalty(arrive_time)
+            f.writelines(f'\n{person_name},{arrive_time},{date},{penalty}')
+      
+    f = open(attendance_file.name,'r',encoding = 'utf-8')
+    df = pd.read_csv(f)
+    return df
+
+
+def prepare_test_img(test_img):
+    test_img = face_recognition.load_image_file(test_img)
+    #test_img = cv2.cvtColor(test_img,cv2.COLOR_BGR2RGB)
+    test_img_small = cv2.resize(test_img,(0,0),None,0.5,0.5)
+
+    face_test_locations = face_recognition.face_locations(test_img_small, model = "hog")
+    encoded_tests = face_recognition.face_encodings(test_img_small)
+    return test_img, encoded_tests, face_test_locations
+
+
+def test(encoded_tests, face_test_locations, test_img, encoded_trains, attendance_file):
+    images = os.listdir(path)
+    name_indices = []
+    df ="No Faces Found" #for handling an error when no faces detected
+
+    for encoded_test, face_test_location in zip(encoded_tests, face_test_locations):
+        results = face_recognition.compare_faces(encoded_trains,encoded_test,tolerance=0.49)
+        # face_distances = face_recognition.face_distance(encoded_trains,encoded_test)
+        # st.write(min(face_distances))
+
+        if True in results:
+            name_index = results.index(True)
+            name_indices.append(name_index)
+
+            for count, image in enumerate(images):
+                if count == name_index:
+                    person_name = image.split(".")[0]
+                    top_left, bottom_right = (face_test_location[3]*scale, face_test_location[0]*scale) ,(face_test_location[1]*scale, face_test_location[2]*scale)
+                    cv2.rectangle(test_img,(top_left),(bottom_right),(255,0,255),2)
+                    cv2.rectangle(test_img,(bottom_right),(top_left[0], bottom_right[1]+30),(255,0,255),cv2.FILLED)
+                    cv2.putText(test_img,person_name,(top_left[0]+6,bottom_right[1]+25),cv2.FONT_HERSHEY_COMPLEX,1,(255,255,255),1)
+                    df=markattendance(person_name, attendance_file)
+        
+        else:
+            top_left, bottom_right = (face_test_location[3]*scale, face_test_location[0]*scale) ,(face_test_location[1]*scale, face_test_location[2]*scale)
+            cv2.rectangle(test_img,(top_left),(bottom_right),(255,0,255),2)
+            cv2.rectangle(test_img,(bottom_right),(top_left[0], bottom_right[1]+30),(255,0,255),cv2.FILLED)
+            cv2.putText(test_img,"UNKNOWN",(top_left[0]+6,bottom_right[1]+25),cv2.FONT_HERSHEY_COMPLEX,1,(255,255,255),1)
+            f = open(attendance_file.name,'r',encoding = 'utf-8')
+            df = pd.read_csv(f)
+
+# this code was to put attendances in a dictionary but now i'm using pandas 
+    # attendance_list = [False for i in range(len(results))]
+    # for i in name_indices:
+    #     attendance_list[i] = True
+
+    # for image in images:
+    #     names.append(image.split(".")[0])
+
+    # ans = {}
+    # for i, name in enumerate (names):
+    #     ans[name] = attendance_list[i]
+    return (df)
+
+
+
+
+
+
+

README.md

@@ -1,13 +1,13 @@
----
-title: Face Recognition Patricia
-emoji: 🌖
-colorFrom: gray
-colorTo: purple
-sdk: gradio
-sdk_version: 4.36.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: FaceRecognition
+emoji: 📊
+colorFrom: pink
+colorTo: gray
+sdk: streamlit
+sdk_version: 1.21.0
+app_file: app.py
+pinned: false
+license: cc
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

Training.py

@@ -0,0 +1,24 @@
+import cv2
+import face_recognition
+import os
+# import streamlit as st
+# import pickle
+# Declaring variables
+path = "db"
+
+def training(path):
+    images = os.listdir(path)  
+    encoded_trains =[]
+
+    for image in images:
+        train_img = face_recognition.load_image_file(f"db/{image}")
+        train_img = cv2.cvtColor(train_img,cv2.COLOR_BGR2RGB)
+        encoded_trains.append(face_recognition.face_encodings(train_img)[0])
+    return encoded_trains, images
+
+
+# encoded_trains, images = training(path)
+# st.write(images)
+# output_file = 'encoded_faces.pickle'
+# with open(output_file, 'wb') as f_out:
+#     pickle.dump(encoded_trains, f_out)

app.py

@@ -0,0 +1,155 @@
+import streamlit as st
+import time
+import cv2
+import pickle
+import face_recognition
+from Preparing_local import prepare_test_img, test
+from PIL import Image
+import os
+
+
+# Define the path to the 'db' directory
+db_folder = 'db'
+
+# Create the 'db' directory if it doesn't exist
+if not os.path.exists(db_folder):
+    os.makedirs(db_folder)
+
+
+t0= time.time()
+# print("Hello")
+# Declaring variables
+path = "db"
+
+
+def main():
+    # Loading the mode
+    #@st.cache
+    def load_model():
+        with open ('encoded_faces.pickle', 'rb') as f_in:
+            encoded_trains = pickle.load(f_in)
+        return encoded_trains
+    encoded_trains = load_model()
+
+    # Start of the project
+    st.title("Attendance Management System Using Face Recognition")
+    st.sidebar.title("Take Attendance")
+    app_mode = st.sidebar.selectbox("Choose Mode",
+    ["Attend from image", "Attend using camera", "Training","Add New Student"])
+
+
+    if app_mode == "Attend from image":     
+        attendance_file = st.file_uploader("Choose attendance file",type =['csv'])
+        uploaded_file = st.file_uploader("Upload a picture of a student to mark the attendance", type=['jpg', 'jpeg', 'png'])
+        if attendance_file is not None and uploaded_file is not None:   
+
+            test_img, encoded_tests, face_test_locations = prepare_test_img(uploaded_file)
+            df = test(encoded_tests, face_test_locations, test_img, encoded_trains, attendance_file)
+            t1 = time.time() - t0
+
+            st.write("Time elapsed: ", t1)
+            # test_img = cv2.resize(test_img,(0,0),None,0.50,0.50) 
+            st.image(test_img)
+            st.write(df)
+
+
+    elif app_mode == "Attend using camera":
+        attendance_file = st.file_uploader("Choose attendance file",type =['csv'])
+        picture = st.camera_input("Take a picture")
+        if picture is not None and attendance_file is not None:
+
+            test_img, encoded_tests, face_test_locations = prepare_test_img(picture)
+            df = test(encoded_tests, face_test_locations, test_img, encoded_trains, attendance_file)
+            t1 = time.time() - t0
+
+            st.write("Time elapsed: ", t1)
+            #test_img = cv2.resize(test_img,(0,0),None,0.50,0.50) 
+            st.image(test_img)
+            st.write(df)
+
+
+    elif app_mode == "Training":
+        st.subheader('Training Steps:')
+        st.markdown("1. Get a photo of every Student with **only one face** in the picture.")
+        st.markdown('2. Put all the photos in the **db** folder')
+        st.markdown("3. Press **Train The Model** Button")
+
+        if st.button("Train The Model"):
+            import Training
+            encoded_trains, images = Training.training(path)
+            st.write(images)
+            st.write(len(encoded_trains))
+            output_file = 'encoded_faces.pickle'
+
+            with open(output_file, 'wb') as f_out:
+                pickle.dump(encoded_trains, f_out)
+            
+
+    elif app_mode == "Attend Live":
+        st.title("Webcam Live Feed")
+        attendance_file = st.file_uploader("Choose attendance file",type =['csv'])
+
+        if attendance_file is not None:
+            run = st.checkbox('Run')
+            FRAME_WINDOW = st.image([])
+            camera = cv2.VideoCapture(2)
+
+            while run:
+                _, test_img = camera.read()
+                test_img = cv2.cvtColor(test_img, cv2.COLOR_BGR2RGB)
+                test_img_small = cv2.resize(test_img,(0,0),None,0.5,0.5)
+
+                face_test_locations = face_recognition.face_locations(test_img_small, model = "hog")
+                encoded_tests = face_recognition.face_encodings(test_img_small)
+                df = test(encoded_tests, face_test_locations, test_img, encoded_trains, attendance_file)
+                #st.image(test_img)
+                FRAME_WINDOW.image(test_img)
+                #st.write(df)
+          
+
+
+    elif app_mode == "Add New Student":
+        st.title("Register Here")
+        Name = st.text_input('Enter Your Name:')  
+        def load_image(image_file):
+            img = Image.open(image_file)
+            return img
+
+        image_file = st.camera_input("Take a picture")
+
+
+        if image_file is not None:
+            # TO See details
+            file_details = Name
+            st.write("Your Name:"+file_details)
+            st.image(load_image(image_file), width=250)
+            
+            #Saving upload
+        
+
+            
+            with open(os.path.join("db",Name+'.jpg'),"wb") as f:
+                f.write((image_file).getbuffer())
+            
+                st.success("File Saved successfully")
+                st.write("Now,Please click on Register Button")
+
+                if st.button("Register"):
+                    import Training
+                    encoded_trains, images = Training.training(path)
+                    st.write(images)
+                    st.write(len(encoded_trains))
+                    output_file = 'encoded_faces.pickle'
+
+                    with open(output_file, 'wb') as f_out:
+                        pickle.dump(encoded_trains, f_out)
+
+
+
+    else:
+        st.write('Stopped')
+
+
+
+if __name__=='__main__':
+    main()

encoded_faces.pickle

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

requirements.txt

@@ -0,0 +1,5 @@
+dlib
+pandas
+numpy
+face_recognition
+opencv-python