{"id":14977917,"url":"https://github.com/kunalyelne/face-recognition-using-raspberry-pi","last_synced_at":"2025-10-11T11:09:39.389Z","repository":{"id":177211812,"uuid":"143142260","full_name":"kunalyelne/Face-Recognition-using-Raspberry-Pi","owner":"kunalyelne","description":"A small project which does face detection using OpenCV library.","archived":false,"fork":false,"pushed_at":"2020-04-24T14:31:24.000Z","size":192,"stargazers_count":81,"open_issues_count":0,"forks_count":37,"subscribers_count":3,"default_branch":"master","last_synced_at":"2025-04-08T16:55:12.267Z","etag":null,"topics":["ai","face-detection","face-recognition","machine-learning","opencv","raspberry-pi","raspberry-pi-3","raspberry-pi-camera","raspbian-stretch"],"latest_commit_sha":null,"homepage":null,"language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/kunalyelne.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2018-08-01T10:39:49.000Z","updated_at":"2025-03-15T17:40:50.000Z","dependencies_parsed_at":null,"dependency_job_id":"e58d5ff5-eefa-4260-8229-11cbc4529ab0","html_url":"https://github.com/kunalyelne/Face-Recognition-using-Raspberry-Pi","commit_stats":{"total_commits":13,"total_committers":1,"mean_commits":13.0,"dds":0.0,"last_synced_commit":"c7db8c9a372bcefbfa1d6a46e77ba704e3b4b216"},"previous_names":["kunalyelne/face-recognition-using-raspberry-pi"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/kunalyelne/Face-Recognition-using-Raspberry-Pi","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kunalyelne%2FFace-Recognition-using-Raspberry-Pi","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kunalyelne%2FFace-Recognition-using-Raspberry-Pi/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kunalyelne%2FFace-Recognition-using-Raspberry-Pi/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kunalyelne%2FFace-Recognition-using-Raspberry-Pi/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/kunalyelne","download_url":"https://codeload.github.com/kunalyelne/Face-Recognition-using-Raspberry-Pi/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kunalyelne%2FFace-Recognition-using-Raspberry-Pi/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":279007031,"owners_count":26084226,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-10-11T02:00:06.511Z","response_time":55,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["ai","face-detection","face-recognition","machine-learning","opencv","raspberry-pi","raspberry-pi-3","raspberry-pi-camera","raspbian-stretch"],"created_at":"2024-09-24T13:56:32.793Z","updated_at":"2025-10-11T11:09:39.361Z","avatar_url":"https://github.com/kunalyelne.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Face-Recognition-using-Raspberry-Pi\n## Description \nA small project which does face detection using OpenCV library on RaspberryPi.\n## Content\n1. [What's Raspberry pi?](#rpi)\n2. [Face Recognition?](#facerecognition)\n3. [OpenCV Library?](#opencv)\n4. [Project](#project)\n   * [Requirements](#requirements)\n   * [Procedure](#procedure)\n\u003ca name=\"rpi\"\u003e \u003c/a\u003e   \n## What's Raspberry pi?\n\u003e Raspberry pi is a mini computer(credit card sized), which is capable of doing various tasks but with less computation power as it doesn't have powerful resources. The Raspberry Pi is slower than a modern laptop or desktop but is still a complete Linux computer and can provide all the expected abilities that implies, at a low-power consumption level.  \n[Explore more](https://www.raspberrypi.org/)\n\u003ca name=\"facerecognition\"\u003e \u003c/a\u003e\n## what is Face Recognition?\n\u003e Face Recognition/Facial Recognition is a category of biometric software which identifies people by their faces. Face is captured by digital camera and the system is trained and then it is capable of identifying the person.\n\u003ca name=\"opencv\"\u003e\u003c/a\u003e\n## OpenCV Library\n\u003e OpenCV (Open Source Computer Vision Library) is an open source computer vision and machine learning software library. OpenCV was built to provide a common infrastructure for computer vision applications and to accelerate the use of machine perception in the commercial products. It has C++, Python and Java interfaces and supports Windows, Linux, Mac OS, iOS and Android.  \n[Read more](https://opencv.org)\n## Project\n\u003e In this project we will learn how to detect real-time faces on Picam.\n\u003ca name=\"requirements\"\u003e \u003c/a\u003e\n### Stuff used in this projects\n1. [Raspberry Pi 3 Model-B](https://www.raspberrypi.org/products/raspberry-pi-3-model-b/)\n2. [Raspberry Pi camera module](https://www.amazon.in/gp/product/B00L1FOIIS/ref=oh_aui_detailpage_o07_s00?ie=UTF8\u0026psc=1)\n### Softwares\n1. [OpenCV Library](https://opencv.org)\n2. [Python3](https://www.python.org)\n3. [TextEditor](https://atom.io)\n\n## 1] Introduction :\n\u003eThis project was done with \"Open Source Computer Vision Library\", the OpenCV. In this project, we will be using Raspberry Pi (so, Raspbian as OS) and Python.OpenCV was designed for computational efficiency and with a strong focus on real-time applications. So, it's perfect for real-time face recognition using a camera.\n\n## 2] Project Structure :\n1. Face Detection and Data Gathering.\n2. Train the Sysytem.\n3. Face Recognition.\n\u003ca name=\"procedure\"\u003e\u003c/a\u003e\n## 3] Procedure :\n**Step 1: Installing OpenCV library**\n\u003e I am using a Raspberry Pi V3 updated to the last version of Raspbian (Stretch), so the best way to have OpenCV installed, is to follow the awesome tutorial developed by Adrian Rosebrock: [Raspbian Stretch: Install OpenCV 3 + Python on your Raspberry Pi](https://www.pyimagesearch.com/2017/09/04/raspbian-stretch-install-opencv-3-python-on-your-raspberry-pi/)\n\n\u003e Once you finished the tutorial, you should have an OpenCV virtual environment ready to run our experiments on your Pi.\nLet's go to our virtual environment and confirm that OpenCV 3 is correctly installed.\n\nRun the command `source` each time you open up a new terminal to ensure your system variables have been set up correctly.  \n`source ~/.profile` \n\nNext, let's enter on our virtual environment:  \n`workon cv`\n\nIf you see the text (cv) preceding your prompt, then you are in the cv virtual environment:  \n`(cv) pi@raspberry:~$`\n\nNow, enter in your Python interpreter :  \n`python`\n\nthen import the OpenCV library :  \n`\u003e\u003eimport cv2`\n\nIf no error messages appear, the OpenCV is correctly installed ON YOUR PYTHON VIRTUAL ENVIRONMENT.\n\nYou can also check the OpenCV version installed:  \n`cv2.__version__`\n\n**Step 2: Testing Camera**\n\u003e Once you have OpenCV installed in your Raspberry Pi, let's test to confirm that your camera is working properly.\nI am assuming that you have a PiCam already installed on your Raspberry Pi.\n\n\u003e You must have the camera enabled when you ran through Adrian's tutorial, otherwise, the drivers will not be installed correctly.\n\nIn case you get an error like: OpenCV Error: Assertion failed , you can try solve the issue, using the command:  \n`sudo modprobe bcm2835-v4l2`\n\nOnce you have all drivers correctly installed, enter the below Python code on your IDE or any Text Editor :  \n```python\nimport numpy as np\nimport cv2\ncap = cv2.VideoCapture(0)\ncap.set(3,640) # set Width\ncap.set(4,480) # set Height\nwhile(True):\n    ret, frame = cap.read()\n    if ret:\n        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n        cv2.imshow('frame', frame)\n        cv2.imshow('gray', gray)\n\n        k = cv2.waitKey(30) \u0026 0xff\n    if k == 27: # press 'ESC' to quit\n        break\ncap.release()\ncv2.destroyAllWindows()\n```\nThe above code will capture the video stream that will be generated by your PiCam, displaying both, in BGR color and Gray mode.\nYou can download the code [CamTest.py](CamTest.py) from above as well.\nNow, Run the program :  \n`python CamTest.py`\n\nSome may found issues when trying to open the camera ( \"Assertion failed\" error messages). That could happen if the camera was not enabled during OpenCv installation and so, camera drivers did not install correctly. To correct, use the command:  \n`sudo modprobe bcm2835-v4l2`\n\n**Step 3: Face Detection**\n\u003e The most basic task on Face Recognition is of course, \"Face Detecting\". Before anything, you must \"capture\" a face in order to recognize it, when compared with a new face captured on future.\n\n\u003e The most common way to detect a face (or any objects), is using the \"Haar Cascade classifier\"\n\n\u003e Object Detection using Haar feature-based cascade classifiers is an effective object detection method proposed by Paul Viola and Michael Jones in their paper, \"Rapid Object Detection using a Boosted Cascade of Simple Features\" in 2001. It is a machine learning based approach where a cascade function is trained from a lot of positive and negative images. It is then used to detect objects in other images.\n\n\u003e Here we will work with face detection. Initially, the algorithm needs a lot of positive images (images of faces) and negative images (images without faces) to train the classifier. Then we need to extract features from it. The good news is that OpenCV comes with a trainer as well as a detector. If you want to train your own classifier for any object like car, planes etc. you can use OpenCV to create one. Its full details are given here: [Cascade Classifier Training.](https://docs.opencv.org/3.3.0/dc/d88/tutorial_traincascade.html)\n\nEnough theory, let's create a face detector with OpenCV!\n\nDownload the file: [FaceDetection.py](FaceDetection.py)\n\n```python\nimport numpy as np\nimport cv2\nfaceCascade = cv2.CascadeClassifier('/home/pi/opencv-3.4.1/data/haarcascades/haarcascade_frontalface_default.xml')\ncap = cv2.VideoCapture(0)\ncap.set(3,640) # set Width\ncap.set(4,480) # set Height\nwhile True:\n    ret, img = cap.read()\n    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n    faces = faceCascade.detectMultiScale(\n        gray,\n        scaleFactor=1.2,\n        minNeighbors=5,\n        minSize=(20,20)\n    )\n    for (x,y,w,h) in faces:\n        cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)\n        roi_gray = gray[y:y+h, x:x+w]\n        roi_color = img[y:y+h, x:x+w]\n    cv2.imshow('video',img)\n    k = cv2.waitKey(30) \u0026 0xff\n    if k == 27: # press 'ESC' to quit\n        break\ncap.release()\ncv2.destroyAllWindows()\n```\n\nWhen you compare with the last code used to test the camera, you will realize that few parts were added to it. Note the line below:  \n`faceCascade = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')`  \nThis is the line that loads the \"classifier\" (that must be in a directory named \"Cascades/\", under your project directory).\n\nThen, we will set our camera and inside the loop, load our input video in grayscale mode (same we saw before).\n\nNow we must call our classifier function, passing it some very important parameters, as scale factor, number of neighbors and minimum size of the detected face.\n\n```python\nfaces = faceCascade.detectMultiScale(\n        gray,     \n        scaleFactor=1.2,\n        minNeighbors=5,     \n        minSize=(20, 20)\n    )\n```\n\nWhere,\n\n`* gray` is the input grayscale image.  \n`* scaleFactor` is the parameter specifying how much the image size is reduced at each image scale. It is used to create the scale pyramid.  \n`* minNeighbors` is a parameter specifying how many neighbors each candidate rectangle should have, to retain it. A higher number gives lower false positives.  \n`* minSize` is the minimum rectangle size to be considered a face.  \n\nThe function will detect faces on the image. Next, we must \"mark\" the faces in the image, using, for example, a blue rectangle. This is done with this portion of the code:  \n```python\nfor (x,y,w,h) in faces:\n    cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)\n    roi_gray = gray[y:y+h, x:x+w]\n    roi_color = img[y:y+h, x:x+w]\n```\nIf faces are found, it returns the positions of detected faces as a rectangle with the left up corner (x,y) and having \"w\" as its Width and \"h\" as its Height ==\u003e (x,y,w,h).\n\nNow, run the above python Script on your python environment, using the Raspberry Pi Terminal:  \n`python FaceDetection.py`\n\nAfter executing the above code you will be able to see a window popping which includes your face.\n\nYou can also include classifiers for \"eyes detection\" or even \"smile detection\". On those cases, you will include the classifier function and rectangle draw inside the face loop, because would be no sense to detect an eye or a smile outside of a face.\n\n\u003e [* .FaceEyeDetection.py](FaceEyeDetection.py)\n\u003e [* .FaceSmileDetection.py](FaceSmileDetection.py)\n\u003e [* .FaceEyeSmileDetection.py](FaceEyeSmileDetection.py)\n\n**Step 4: Data Gathering**\n\u003e Let's start the first phase of our project. What we will do here, is starting from Face Detecting, we will simply create a dataset, where we will store for each id, a group of photos in gray with the portion that was used for face detecting.\n\nFirst, create a directory where you develop your project, for example, FaceRecognition:  \n`mkdir FaceRecognition`\n\nIn this directory, besides the 3 python scripts that we will create for our project, we must have saved on it the Facial Classifier. You can download it from above: [haarcascade_frontalface_default.xml](haarcascade_frontalface_default.xml)\n\nNext, create a subdirectory where we will store our facial samples and name it \"dataset\":  \n`mkdir dataset`\n\n\u003e Download [01_face_dataset.py](01_face_dataset.py)\n\n```python\nimport cv2\nimport os\ncam = cv2.VideoCapture(0)\ncam.set(3, 640) # set video width\ncam.set(4, 480) # set video height\nface_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')\n# For each person, enter one numeric face id\nface_id = input('\\n Enter user ID end press \u003cEnter\u003e ==\u003e  ')\nprint(\"\\n Initializing face capture. Look the camera and wait ...\")\n# Initialize individual sampling face count\ncount = 0\nwhile(True):\n    ret, img = cam.read()\n    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n    faces = face_detector.detectMultiScale(gray, 1.3, 5)\n    for (x,y,w,h) in faces:\n        cv2.rectangle(img, (x,y), (x+w,y+h), (255,0,0), 2)\n        count += 1\n        # Save the captured image into the datasets folder\n        cv2.imwrite(\"dataset/User.\" + str(face_id) + '.' + str(count) + \".jpg\", gray[y:y+h,x:x+w])\n        cv2.imshow('image', img)\n    k = cv2.waitKey(100) \u0026 0xff # Press 'ESC' for exiting video\n    if k == 27:\n        break\n    elif count \u003e= 30: # Take 30 face sample and stop video\n         break\n# Do a bit of cleanup\nprint(\"\\n [INFO] Exiting Program and cleanup stuff\")\ncam.release()\ncv2.destroyAllWindows()\n```\nThe code is very similar to the code that we saw for face detection. What we added, was an \"input command\" to capture a user id, that should be an integer number (1, 2, 3, etc)  \n`face_id = input('\\n enter user id end press  ==\u003e  ')`\n\nAnd for each one of the captured frames, we should save it as a file on a \"dataset\" directory:\n`cv2.imwrite(\"dataset/User.\" + str(face_id) + '.' + str(count) + \".jpg\", gray[y:y+h,x:x+w])`  \n\nNote that for saving the above file, you must have imported the library \"os\". Each file's name will follow the structure:\n`User.face_id.count.jpg`  \n\nFor example, for a user with a face_id = 1, the 4th sample file on dataset/ directory will be something like:  \n`User.1.4.jpg`\n\nIn code, you guys can see the there's a `count` variable which counts no. of images captured. It is set to `30` , the more you capture the more accuratly system will work.\n\n**Step 6: Trainer**\n\u003e On this second phase, we must take all user data from our dataset and \"trainer\" the OpenCV Recognizer. This is done directly by a specific OpenCV function. The result will be a `.yml` file that will be saved on a \"trainer/\" directory.\n\nSo, let's create trainer directory first:  \n`mkdir trainer`\n\nDownload [02_face_training.py](02_face_training.py)  \n```python\nimport cv2\nimport numpy as np\nfrom PIL import Image\nimport os\n# Path for face image database\npath = 'dataset'\n\nos.chdir(\"/home/pi/opencv-3.4.1/data/haarcascades\")\nrecognizer = cv2.face.LBPHFaceRecognizer_create()\ndetector = cv2.CascadeClassifier(\"/home/pi/opencv-3.4.1/data/haarcascades/haarcascade_frontalface_default.xml\");\n# function to get the images and label data\ndef getImagesAndLabels(path):\n    imagePaths = [os.path.join(path,f) for f in os.listdir(path)]\n    faceSamples=[]\n    ids = []\n    for imagePath in imagePaths:\n        PIL_img = Image.open(imagePath).convert('L') # convert it to grayscale\n        img_numpy = np.array(PIL_img,'uint8')\n        id = int(os.path.split(imagePath)[-1].split(\".\")[1])\n        faces = detector.detectMultiScale(img_numpy)\n        for (x,y,w,h) in faces:\n            faceSamples.append(img_numpy[y:y+h,x:x+w])\n            ids.append(id)\n    return faceSamples,ids\nprint (\"\\nTraining faces. It will take few seconds. Wait ...\")\nfaces,ids = getImagesAndLabels(path)\nrecognizer.train(faces, np.array(ids))\n# Save the model into trainer/trainer.yml\nrecognizer.write('/home/pi/FaceRecognition/trainer/trainer.yml')\n# Print the numer of faces trained and end program\nprint(\"\\n [INFO] {0} faces trained. Exiting Program\".format(len(np.unique(ids))))\n```\nConfirm if you have the PIL library installed on your Raspberry Pi. If not, run the below command in Terminal:  \n`pip install pillow`\n\nWe will use as a recognizer, the LBPH (LOCAL BINARY PATTERNS HISTOGRAMS) Face Recognizer, included in OpenCV package. This can be done by following line:  \n`recognizer = cv2.face.LBPHFaceRecognizer_create()`\n\nThe function \"getImagesAndLabels(path)\", will take all photos on directory: \"dataset/\", returning 2 arrays: \"Ids\" and \"faces\". With those arrays as input, we will \"train our recognizer\":  \n`recognizer.train(faces, ids)`\n\nAs a result, a file named \"trainer.yml\" will be saved in the trainer directory that was previously created by us.  \n\u003e_Note: Make sure that whenever you collect dataset i.e run program 1, you must run program 2 as well to train Rpi._  \n\n**Step 6: Recognizer**\n\u003e Now, we reached the final phase of our project. Here, we will capture a fresh face on our camera and if this person had his face captured and trained before, our recognizer will make a \"prediction\" returning its id and an index, shown how confident the recognizer is with this match.\n\n Download [03_face_recognition.py](03_face_recognition.py)  \n```python\nimport cv2\nimport numpy as np\nimport os\n\nos.chdir(\"/home/pi/opencv-3.4.1/data/haarcascades\")\nrecognizer = cv2.face.LBPHFaceRecognizer_create()\nrecognizer.read('/home/pi/FaceRecognition/trainer/trainer.yml')\ncascadePath = \"/home/pi/opencv-3.4.1/data/haarcascades/haarcascade_frontalface_default.xml\"\nfaceCascade = cv2.CascadeClassifier(cascadePath);\n\nfont = cv2.FONT_HERSHEY_SIMPLEX\n\n#iniciate id counter\nid = 0\n\n# names related to ids: example ==\u003e KUNAL: id=1,  etc\nnames = ['None', 'Kunal', 'Kaushik', 'Atharv', 'Z', 'W']\n\n# Initialize and start realtime video capture\ncam = cv2.VideoCapture(0)\ncam.set(3, 640) # set video widht\ncam.set(4, 480) # set video height\n\n# Define min window size to be recognized as a face\nminW = 0.1*cam.get(3)\nminH = 0.1*cam.get(4)\n\nwhile True:\n    ret, img =cam.read()\n    #img = cv2.flip(img, -1) # Flip vertically\n    gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n\n    faces = faceCascade.detectMultiScale(\n        gray,\n        scaleFactor = 1.2,\n        minNeighbors = 5,\n        minSize = (int(minW), int(minH)),\n       )\n\n    for(x,y,w,h) in faces:\n        cv2.rectangle(img, (x,y), (x+w,y+h), (0,255,0), 2)\n        id, confidence = recognizer.predict(gray[y:y+h,x:x+w])\n\n        # Check if confidence is less them 100 ==\u003e \"0\" is perfect match\n        if (confidence \u003c 100):\n            id = names[id]\n            confidence = \"  {0}%\".format(round(100 - confidence))\n        else:\n            id = \"unknown\"\n            confidence = \"  {0}%\".format(round(100 - confidence))\n\n        cv2.putText(img, str(id), (x+5,y-5), font, 1, (255,255,255), 2)\n        cv2.putText(img, str(confidence), (x+5,y+h-5), font, 1, (255,255,0), 1)\n\n    cv2.imshow('camera',img)\n\n    k = cv2.waitKey(10) \u0026 0xff # Press 'ESC' for exiting video\n    if k == 27:\n        break\n\n# Do a bit of cleanup\nprint(\"\\n [INFO] Exiting Program and cleanup stuff\")\ncam.release()\ncv2.destroyAllWindows()\n```\nWe are including here a new array, so we will display \"names\", instead of numbered ids:\n\nnames = ['None', 'Kunal', 'Kaushik', 'Tushar', 'X', 'Y' , 'Z']\nSo, for example: Kunal will be the user with id = 1; Kaushik: id=2, etc.\n\nNext, we will detect a face, same we did before with the haarCascade classifier. Having a detected face we can call the most important function in the above code:  \n`id, confidence = recognizer.predict(gray portion of the face)`\n\nThe `recognizer.predict ()`, will take as a parameter a captured portion of the face to be analyzed and will return its probable owner, indicating its id and how much confidence the recognizer is in relation with this match.\n\n\u003e_Note that the confidence index will return **\"zero\"** if it will be cosidered a perfect match_\n\n**Below is the final result image, you too should get similar output**\n\n\u003cdiv style=\"align:center\"\u003e\n  \u003cimg src =\"/images/result.jpg\"/\u003e\n\u003c/div\u003e\n\n## Conclusion:\n\u003e I hope this project can help others find their way into the exciting world of IoT!\n\nFor more projects, follow me on github [Kunal Yelne](https://github.com/kunalyelne):+1:  \nThankyou :heart:\n\n## Credits\n[Kunal Yelne](https://github.com/kunalyelne)  \n3rd Year,CSE Department.  \n[Indian Institute of Information Technology Nagpur.](https://github.com/iiit-nagpur)\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fkunalyelne%2Fface-recognition-using-raspberry-pi","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fkunalyelne%2Fface-recognition-using-raspberry-pi","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fkunalyelne%2Fface-recognition-using-raspberry-pi/lists"}