Upload 25 files

.gitattributes

@@ -32,3 +32,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
+emotion_detection/Modelos/model_dropout.hdf5 filter=lfs diff=lfs merge=lfs -text
+results/Face_ID.gif filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,129 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

Face_info.py

@@ -0,0 +1,45 @@
+import f_Face_info
+import cv2
+import time
+import imutils
+import argparse
+
+parser = argparse.ArgumentParser(description="Face Info")
+parser.add_argument('--input', type=str, default= 'webcam',
+                    help="webcam or image")
+parser.add_argument('--path_im', type=str,
+                    help="path of image")
+args = vars(parser.parse_args())
+
+type_input = args['input']
+if type_input == 'image':
+    # ----------------------------- image -----------------------------
+    #ingestar data
+    frame = cv2.imread(args['path_im'])
+    # obtenego info del frame
+    out = f_Face_info.get_face_info(frame)
+    # pintar imagen
+    res_img = f_Face_info.bounding_box(out,frame)
+    cv2.imshow('Face info',res_img)
+    cv2.waitKey(0)
+
+if type_input == 'webcam':
+    # ----------------------------- webcam -----------------------------
+    cv2.namedWindow("Face info")
+    cam = cv2.VideoCapture(0)
+    while True:
+        star_time = time.time()
+        ret, frame = cam.read()
+        frame = imutils.resize(frame, width=720)
+        
+        # obtenego info del frame
+        out = f_Face_info.get_face_info(frame)
+        # pintar imagen
+        res_img = f_Face_info.bounding_box(out,frame)
+
+        end_time = time.time() - star_time    
+        FPS = 1/end_time
+        cv2.putText(res_img,f"FPS: {round(FPS,3)}",(10,50),cv2.FONT_HERSHEY_COMPLEX,1,(0,0,255),2)
+        cv2.imshow('Face info',res_img)
+        if cv2.waitKey(1) &0xFF == ord('q'):
+            break

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Juan Camilo López Montes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,12 +1,31 @@
----
-title: FaceRecognition
-emoji: 💻
-colorFrom: red
-colorTo: blue
-sdk: gradio
-sdk_version: 3.33.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Face Info
+Face Info is an implementation of facial recognition, detection of facial attributes (age, gender, emotion and race) for python.
+The repository provides a script to run Face Info with the webcam or by entering the path of an image.
+This implementation allows recognition of multiple faces and the registration of new users for facial recognition.
+
+# How to install:
+<pre><code>pip install -r requirements.txt </code></pre>
+
+
+# How to run:
+The code is tested in python 3.7.8 and macOS Catalina
+<pre><code>python Face_info.py --input webcam </code></pre>
+![alt text](https://github.com/juan-csv/Face_info/blob/master/results/Face_ID.gif)
+
+
+
+running over an image
+<pre><code>python Face_info.py --input image --path_im data_test/friends.jpg </code></pre>
+![alt text](https://github.com/juan-csv/Face_info/blob/master/results/result.png)
+
+
+# Add new faces to the database (facial recognition)
+You can add new users to the faces database simply by adding the person's photo in the **images_db** folder, for the registry to work correctly, only the person of interest should appear in the photo.
+
+# References
+
+- **Emotion detection:** https://github.com/juan-csv/emotion_detection
+- **Face Recognition:** https://github.com/juan-csv/face-recognition
+- **Age detection:** https://github.com/serengil/deepface
+- **Gender detection:** https://github.com/serengil/deepface
+- **Race detection:** https://github.com/serengil/deepface

age_detection/f_my_age.py

@@ -0,0 +1,70 @@
+"""
+como usar
+1.instalar la libreria deepface
+    pip install deepface
+2. instanciar el modelo
+	emo = f_my_emotion.Age_Model()
+3. ingresar una imagen donde solo se vea un rostro (usar modelo deteccion de rostros para extraer una imagen con solo el rostro)
+	emo.predict_age(face_image)
+"""
+
+
+#from basemodels import VGGFace
+from deepface.basemodels import VGGFace
+import os
+from pathlib import Path
+import gdown
+import numpy as np
+from keras.models import Model, Sequential
+from keras.layers import Convolution2D, Flatten, Activation
+from keras.preprocessing import image
+import cv2
+
+
+class Age_Model():
+    def __init__(self):
+        self.model = self.loadModel()
+        self.output_indexes = np.array([i for i in range(0, 101)])
+    
+    def predict_age(self,face_image):
+        image_preprocesing = self.transform_face_array2age_face(face_image)
+        age_predictions = self.model.predict(image_preprocesing )[0,:]
+        result_age = self.findApparentAge(age_predictions)
+        return result_age
+
+    def loadModel(self):
+        model = VGGFace.baseModel()
+        #--------------------------
+        classes = 101
+        base_model_output = Sequential()
+        base_model_output = Convolution2D(classes, (1, 1), name='predictions')(model.layers[-4].output)
+        base_model_output = Flatten()(base_model_output)
+        base_model_output = Activation('softmax')(base_model_output)
+        #--------------------------
+        age_model = Model(inputs=model.input, outputs=base_model_output)
+        #--------------------------
+        #load weights
+        home = str(Path.home())
+        if os.path.isfile(home+'/.deepface/weights/age_model_weights.h5') != True:
+            print("age_model_weights.h5 will be downloaded...")
+            url = 'https://drive.google.com/uc?id=1YCox_4kJ-BYeXq27uUbasu--yz28zUMV'
+            output = home+'/.deepface/weights/age_model_weights.h5'
+            gdown.download(url, output, quiet=False)
+        age_model.load_weights(home+'/.deepface/weights/age_model_weights.h5')
+        return age_model
+        #--------------------------
+
+    def findApparentAge(self,age_predictions):
+        apparent_age = np.sum(age_predictions * self.output_indexes)
+        return apparent_age
+
+    def transform_face_array2age_face(self,face_array,grayscale=False,target_size = (224, 224)):
+        detected_face = face_array
+        if grayscale == True:
+            detected_face = cv2.cvtColor(detected_face, cv2.COLOR_BGR2GRAY)
+        detected_face = cv2.resize(detected_face, target_size)
+        img_pixels = image.img_to_array(detected_face)
+        img_pixels = np.expand_dims(img_pixels, axis = 0)
+        #normalize input in [0, 1]
+        img_pixels /= 255
+        return img_pixels

config.py

@@ -0,0 +1,12 @@
+# -------------------------------------- emotion_detection ---------------------------------------
+# modelo de deteccion de emociones
+path_model = 'emotion_detection/Modelos/model_dropout.hdf5'
+# Parametros del modelo, la imagen se debe convertir a una de tamaño 48x48 en escala de grises
+w,h = 48,48
+rgb = False
+labels = ['angry','disgust','fear','happy','neutral','sad','surprise']
+
+# -------------------------------------- face_recognition ---------------------------------------
+# path imagenes folder
+path_images = "images_db"
+

deep_face.py

@@ -0,0 +1,9 @@
+from deepface import DeepFace
+demography = DeepFace.analyze("juan.jpg", actions = ['age', 'gender', 'race', 'emotion'])
+#demographies = DeepFace.analyze(["img1.jpg", "img2.jpg", "img3.jpg"]) #analyzing multiple faces same time
+print("Age: ", demography["age"])
+print("Gender: ", demography["gender"])
+print("Emotion: ", demography["dominant_emotion"])
+print("Race: ", demography["dominant_race"])
+
+

emotion_detection/Modelos/model_dropout.hdf5

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

emotion_detection/f_emotion_detection.py

@@ -0,0 +1,37 @@
+import config as cfg
+import cv2
+import numpy as np
+from keras.models import load_model
+from keras.preprocessing.image import img_to_array
+
+class predict_emotions():
+    def __init__(self):
+        # cargo modelo de deteccion de emociones
+        self.model = load_model(cfg.path_model)
+
+    def preprocess_img(self,face_image,rgb=True,w=48,h=48):
+        face_image = cv2.resize(face_image, (w,h))
+        if rgb == False:
+            face_image = cv2.cvtColor(face_image, cv2.COLOR_BGR2GRAY)
+        face_image = face_image.astype("float") / 255.0
+        face_image= img_to_array(face_image)
+        face_image = np.expand_dims(face_image, axis=0)
+        return face_image
+
+    def get_emotion(self,img,boxes_face):
+        emotions = []
+        if len(boxes_face)!=0:
+            for box in boxes_face:
+                y0,x0,y1,x1 = box
+                face_image = img[x0:x1,y0:y1]
+                # preprocesar data
+                face_image = self.preprocess_img(face_image ,cfg.rgb, cfg.w, cfg.h)
+                # predecir imagen
+                prediction = self.model.predict(face_image)
+                emotion = cfg.labels[prediction.argmax()]
+                emotions.append(emotion)
+        else:
+            emotions = []
+            boxes_face = []
+        return boxes_face,emotions
+

f_Face_info.py

@@ -0,0 +1,112 @@
+import cv2
+import numpy as np
+import face_recognition
+from age_detection import f_my_age
+from gender_detection import f_my_gender
+from race_detection import f_my_race
+from emotion_detection import f_emotion_detection
+from my_face_recognition import f_main
+
+
+
+# instanciar detectores
+age_detector = f_my_age.Age_Model()
+gender_detector =  f_my_gender.Gender_Model()
+race_detector = f_my_race.Race_Model()
+emotion_detector = f_emotion_detection.predict_emotions()
+rec_face = f_main.rec()
+#----------------------------------------------
+
+
+
+def get_face_info(im):
+    # face detection
+    boxes_face = face_recognition.face_locations(im)
+    out = []
+    if len(boxes_face)!=0:
+        for box_face in boxes_face:
+            # segmento rostro
+            box_face_fc = box_face
+            x0,y1,x1,y0 = box_face
+            box_face = np.array([y0,x0,y1,x1])
+            face_features = {
+                "name":[],
+                "age":[],
+                "gender":[],
+                "race":[],
+                "emotion":[],
+                "bbx_frontal_face":box_face             
+            } 
+
+            face_image = im[x0:x1,y0:y1]
+
+            # -------------------------------------- face_recognition ---------------------------------------
+            face_features["name"] = rec_face.recognize_face2(im,[box_face_fc])[0]
+
+            # -------------------------------------- age_detection ---------------------------------------
+            age = age_detector.predict_age(face_image)
+            face_features["age"] = str(round(age,2))
+
+            # -------------------------------------- gender_detection ---------------------------------------
+            face_features["gender"] = gender_detector.predict_gender(face_image)
+
+            # -------------------------------------- race_detection ---------------------------------------
+            face_features["race"] = race_detector.predict_race(face_image)
+
+            # -------------------------------------- emotion_detection ---------------------------------------
+            _,emotion = emotion_detector.get_emotion(im,[box_face])
+            face_features["emotion"] = emotion[0]
+
+            # -------------------------------------- out ---------------------------------------       
+            out.append(face_features)
+    else:
+        face_features = {
+            "name":[],
+            "age":[],
+            "gender":[],
+            "race":[],
+            "emotion":[],
+            "bbx_frontal_face":[]             
+        }
+        out.append(face_features)
+    return out
+
+
+
+def bounding_box(out,img):
+    for data_face in out:
+        box = data_face["bbx_frontal_face"]
+        if len(box) == 0:
+            continue
+        else:
+            x0,y0,x1,y1 = box
+            img = cv2.rectangle(img,
+                            (x0,y0),
+                            (x1,y1),
+                            (0,255,0),2);
+            thickness = 1
+            fontSize = 0.5
+            step = 13
+
+            try:
+                cv2.putText(img, "age: " +data_face["age"], (x0, y0-7), cv2.FONT_HERSHEY_SIMPLEX, fontSize, (0,255,0), thickness)
+            except:
+                pass
+            try:
+                cv2.putText(img, "gender: " +data_face["gender"], (x0, y0-step-10*1), cv2.FONT_HERSHEY_SIMPLEX, fontSize, (0,255,0), thickness)
+            except:
+                pass
+            try:
+                cv2.putText(img, "race: " +data_face["race"], (x0, y0-step-10*2), cv2.FONT_HERSHEY_SIMPLEX, fontSize, (0,255,0), thickness)
+            except:
+                pass
+            try:
+                cv2.putText(img, "emotion: " +data_face["emotion"], (x0, y0-step-10*3), cv2.FONT_HERSHEY_SIMPLEX, fontSize, (0,255,0), thickness)
+            except:
+                pass
+            try:
+                cv2.putText(img, "name: " +data_face["name"], (x0, y0-step-10*4), cv2.FONT_HERSHEY_SIMPLEX, fontSize, (0,255,0), thickness)
+            except:
+                pass
+    return img
+

gender_detection/f_my_gender.py

@@ -0,0 +1,57 @@
+#from basemodels import VGGFace
+from deepface.basemodels import VGGFace
+import os
+from pathlib import Path
+import gdown
+import numpy as np
+from keras.models import Model, Sequential
+from keras.layers import Convolution2D, Flatten, Activation
+from keras.preprocessing import image
+import cv2
+
+
+class Gender_Model():
+    def __init__(self):
+        self.model = self.loadModel()
+
+    def predict_gender(self, face_image):
+        image_preprocesing = self.transform_face_array2gender_face(face_image)
+        gender_predictions = self.model.predict(image_preprocesing )[0,:]
+        if np.argmax(gender_predictions) == 0:
+            result_gender = "Woman"
+        elif np.argmax(gender_predictions) == 1:
+            result_gender = "Man"
+        return result_gender
+
+    def loadModel(self):
+        model = VGGFace.baseModel()
+        #--------------------------
+        classes = 2
+        base_model_output = Sequential()
+        base_model_output = Convolution2D(classes, (1, 1), name='predictions')(model.layers[-4].output)
+        base_model_output = Flatten()(base_model_output)
+        base_model_output = Activation('softmax')(base_model_output)
+        #--------------------------
+        gender_model = Model(inputs=model.input, outputs=base_model_output)
+        #--------------------------
+        #load weights
+        home = str(Path.home())
+        if os.path.isfile(home+'/.deepface/weights/gender_model_weights.h5') != True:
+            print("gender_model_weights.h5 will be downloaded...")
+            url = 'https://drive.google.com/uc?id=1wUXRVlbsni2FN9-jkS_f4UTUrm1bRLyk'
+            output = home+'/.deepface/weights/gender_model_weights.h5'
+            gdown.download(url, output, quiet=False)
+        gender_model.load_weights(home+'/.deepface/weights/gender_model_weights.h5')
+        return gender_model
+        #--------------------------
+
+    def transform_face_array2gender_face(self,face_array,grayscale=False,target_size = (224, 224)):
+        detected_face = face_array
+        if grayscale == True:
+            detected_face = cv2.cvtColor(detected_face, cv2.COLOR_BGR2GRAY)
+        detected_face = cv2.resize(detected_face, target_size)
+        img_pixels = image.img_to_array(detected_face)
+        img_pixels = np.expand_dims(img_pixels, axis = 0)
+        #normalize input in [0, 1]
+        img_pixels /= 255
+        return img_pixels

my_face_recognition/f_face_recognition.py

@@ -0,0 +1,47 @@
+import face_recognition 
+import numpy as np
+
+def detect_face(image):
+    '''
+    Input: imagen numpy.ndarray, shape=(W,H,3)
+    Output: [(y0,x1,y1,x0),(y0,x1,y1,x0),...,(y0,x1,y1,x0)] ,cada tupla representa un rostro detectado
+    si no se detecta nada  --> Output: []
+    '''
+    Output = face_recognition.face_locations(image)
+    return Output
+
+def get_features(img,box):
+    '''
+    Input:
+        -img:imagen numpy.ndarray, shape=(W,H,3)
+        -box: [(y0,x1,y1,x0),(y0,x1,y1,x0),...,(y0,x1,y1,x0)] ,cada tupla representa un rostro detectado
+    Output:
+        -features: [array,array,...,array] , cada array representa las caracteristicas de un rostro 
+    '''
+    features = face_recognition.face_encodings(img,box)
+    return features
+
+def compare_faces(face_encodings,db_features,db_names):
+    '''
+    Input:
+        db_features = [array,array,...,array] , cada array representa las caracteristicas de un rostro 
+        db_names =  array(array,array,...,array) cada array representa las caracteriticas de un usuario
+    Output:
+        -match_name: ['name', 'unknow'] lista con los nombres que hizo match
+        si no hace match pero hay una persona devuelve 'unknow'
+    '''
+    match_name = []
+    names_temp = db_names
+    Feats_temp = db_features           
+
+    for face_encoding in face_encodings:
+        try:
+            dist = face_recognition.face_distance(Feats_temp,face_encoding)
+        except:
+            dist = face_recognition.face_distance([Feats_temp],face_encoding)
+        index = np.argmin(dist)
+        if dist[index] <= 0.6:
+            match_name = match_name + [names_temp[index]]
+        else:
+            match_name = match_name + ["unknow"]
+    return match_name

my_face_recognition/f_main.py

@@ -0,0 +1,107 @@
+from my_face_recognition import f_face_recognition as rec_face
+from my_face_recognition import f_storage as st
+import traceback
+import numpy as np
+import cv2
+
+#------------------------ Inicia el flujo principal ----------------------------
+class rec():
+    def __init__(self):
+        '''
+        -db_names: [name1,name2,...,namen] lista de strings
+        -db_features: array(array,array,...,array) cada array representa las caracteriticas de un usuario
+        '''
+        self.db_names, self.db_features = st.load_images_to_database()
+
+    def recognize_face(self,im):
+        '''
+        Input:
+            -imb64: imagen 
+        Output:
+            res:{'status': si todo sale bien es 'ok' en otro caso devuelve el erroe encontrado
+                'faces': [(y0,x1,y1,x0),(y0,x1,y1,x0),...,(y0,x1,y1,x0)] ,cada tupla representa un rostro detectado
+                'names': ['name', 'unknow'] lista con los nombres que hizo match}       
+        '''
+        try:
+            # detectar rostro 
+            box_faces = rec_face.detect_face(im)
+            # condiconal para el caso de que no se detecte rostro
+            if  not box_faces:
+                res = {
+                    'status':'ok',
+                    'faces':[],
+                    'names':[]}
+                return res
+            else:
+                if not self.db_names:
+                    res = {
+                        'status':'ok',
+                        'faces':box_faces,
+                        'names':['unknow']*len(box_faces)}
+                    return res
+                else:
+                    # (continua) extraer features
+                    actual_features = rec_face.get_features(im,box_faces)
+                    # comparar actual_features con las que estan almacenadas en la base de datos
+                    match_names = rec_face.compare_faces(actual_features,self.db_features,self.db_names)
+                    # guardar
+                    res = {
+                        'status':'ok',
+                        'faces':box_faces,
+                        'names':match_names}
+                    return res
+        except Exception as ex:
+            error = ''.join(traceback.format_exception(etype=type(ex), value=ex, tb=ex.__traceback__))
+            res = {
+                'status':'error: ' + str(error),
+                'faces':[],
+                'names':[]}
+            return res
+        
+    def recognize_face2(self,im,box_faces):
+        try:
+            if not self.db_names:
+                res = 'unknow'
+                return res
+            else:
+                # (continua) extraer features
+                actual_features = rec_face.get_features(im,box_faces)
+                # comparar actual_features con las que estan almacenadas en la base de datos
+                match_names = rec_face.compare_faces(actual_features,self.db_features,self.db_names)
+                # guardar
+                res = match_names
+                return res
+        except:
+            res = []
+            return res
+
+
+def bounding_box(img,box,match_name=[]):
+    for i in np.arange(len(box)):
+        x0,y0,x1,y1 = box[i]
+        img = cv2.rectangle(img,
+                      (x0,y0),
+                      (x1,y1),
+                      (0,255,0),3);
+        if not match_name:
+            continue
+        else:
+            cv2.putText(img, match_name[i], (x0, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0,255,0), 2)
+    return img
+
+if __name__ == "__main__":
+    import argparse
+
+    parse = argparse.ArgumentParser()
+    parse.add_argument("-im","--path_im",help="path image")
+    parse = parse.parse_args()
+    
+    path_im = parse.path_im
+    im = cv2.imread(path_im)
+    # instancio detector
+    recognizer = rec()
+    res = recognizer.recognize_face(im)
+    im = bounding_box(im,res["faces"],res["names"])
+    cv2.imshow("face recogntion", im)
+    cv2.waitKey(0)
+    print(res)

my_face_recognition/f_storage.py

@@ -0,0 +1,57 @@
+'''
+cargo las imagenes que estan en el folder database_images
+'''
+import config as cfg
+import os
+from my_face_recognition import f_main
+import cv2
+import numpy as np
+import traceback
+
+
+def load_images_to_database():
+    list_images = os.listdir(cfg.path_images)
+    # filto los archivos que no son imagenes
+    list_images = [File for File in list_images if File.endswith(('.jpg','.jpeg','JPEG'))]
+
+    # inicalizo variables
+    name = []
+    Feats = []
+
+    # ingesta de imagenes
+    for file_name in list_images:
+        im = cv2.imread(cfg.path_images+os.sep+file_name)
+
+        # obtengo las caracteristicas del rostro
+        box_face = f_main.rec_face.detect_face(im)
+        feat = f_main.rec_face.get_features(im,box_face)
+        if len(feat)!=1:
+            '''
+            esto significa que no hay rostros o hay mas de un rostro
+            '''
+            continue
+        else:
+            # inserto las nuevas caracteristicas en la base de datos
+            new_name = file_name.split(".")[0]
+            if new_name == "":
+                continue
+            name.append(new_name)
+            if len(Feats)==0:
+                Feats = np.frombuffer(feat[0], dtype=np.float64)
+            else:
+                Feats = np.vstack((Feats,np.frombuffer(feat[0], dtype=np.float64)))
+    return name, Feats
+
+def insert_new_user(rec_face,name,feat,im):
+    try:
+        rec_face.db_names.append(name)
+        if len(rec_face.db_features)==0:
+            rec_face.db_features = np.frombuffer(feat[0], dtype=np.float64)
+        else:
+            rec_face.db_features = np.vstack((rec_face.db_features,np.frombuffer(feat[0], dtype=np.float64)))
+        # guardo la imagen
+        cv2.imwrite(cfg.path_images+os.sep+name+".jpg", im) 
+        return 'ok'
+    except Exception as ex:
+        error = ''.join(traceback.format_exception(etype=type(ex), value=ex, tb=ex.__traceback__))
+        return error

race_detection/f_my_race.py

@@ -0,0 +1,67 @@
+"""
+como usar
+1. instanciar el modelo
+	emo = f_my_race.Race_Model()
+2. ingresar una imagen donde solo se vea un rostro (usar modelo deteccion de rostros para extraer una imagen con solo el rostro)
+	emo.predict_race(face_image)
+"""
+
+#from basemodels import VGGFace
+from deepface.basemodels import VGGFace
+import os
+from pathlib import Path
+import gdown
+import numpy as np
+from keras.models import Model, Sequential
+from keras.layers import Convolution2D, Flatten, Activation
+import zipfile
+from keras.preprocessing import image
+import cv2
+
+
+class Race_Model():
+    def __init__(self):
+        self.model = self.loadModel()
+        self.race_labels = ['asian', 'indian', 'black', 'white', 'middle eastern', 'latino hispanic']
+
+    def predict_race(self,face_image):
+        image_preprocesing = self.transform_face_array2race_face(face_image)
+        race_predictions = self.model.predict(image_preprocesing )[0,:]
+        result_race = self.race_labels[np.argmax(race_predictions)]
+        return result_race
+
+    def loadModel(self):
+        model = VGGFace.baseModel()
+        #--------------------------
+        classes = 6
+        base_model_output = Sequential()
+        base_model_output = Convolution2D(classes, (1, 1), name='predictions')(model.layers[-4].output)
+        base_model_output = Flatten()(base_model_output)
+        base_model_output = Activation('softmax')(base_model_output)	
+        #--------------------------
+        race_model = Model(inputs=model.input, outputs=base_model_output)	
+        #--------------------------	
+        #load weights	
+        home = str(Path.home())	
+        if os.path.isfile(home+'/.deepface/weights/race_model_single_batch.h5') != True:
+            print("race_model_single_batch.h5 will be downloaded...")		
+            #zip
+            url = 'https://drive.google.com/uc?id=1nz-WDhghGQBC4biwShQ9kYjvQMpO6smj'
+            output = home+'/.deepface/weights/race_model_single_batch.zip'
+            gdown.download(url, output, quiet=False)		
+            #unzip race_model_single_batch.zip
+            with zipfile.ZipFile(output, 'r') as zip_ref:
+                zip_ref.extractall(home+'/.deepface/weights/')
+        race_model.load_weights(home+'/.deepface/weights/race_model_single_batch.h5')	
+        return race_model
+        #--------------------------
+    def transform_face_array2race_face(self,face_array,grayscale=False,target_size = (224, 224)):
+        detected_face = face_array
+        if grayscale == True:
+            detected_face = cv2.cvtColor(detected_face, cv2.COLOR_BGR2GRAY)
+        detected_face = cv2.resize(detected_face, target_size)
+        img_pixels = image.img_to_array(detected_face)
+        img_pixels = np.expand_dims(img_pixels, axis = 0)
+        #normalize input in [0, 1]
+        img_pixels /= 255
+        return img_pixels

requirements.txt

@@ -0,0 +1,82 @@
+absl-py==0.9.0
+appnope==0.1.0
+astroid==2.4.2
+astunparse==1.6.3
+backcall==0.2.0
+cachetools==4.1.1
+certifi==2020.6.20
+chardet==3.0.4
+click==7.1.2
+decorator==4.4.2
+deepface==0.0.33
+dlib==19.20.0
+face-recognition==1.3.0
+face-recognition-models==0.3.0
+filelock==3.0.12
+Flask==1.1.2
+gast==0.3.3
+gdown==3.12.0
+google-auth==1.19.2
+google-auth-oauthlib==0.4.1
+google-pasta==0.2.0
+grpcio==1.30.0
+h5py==2.10.0
+idna==2.10
+importlib-metadata==1.7.0
+imutils==0.5.3
+ipykernel==5.3.4
+ipython==7.16.1
+ipython-genutils==0.2.0
+isort==4.3.21
+itsdangerous==1.1.0
+jedi==0.17.2
+Jinja2==2.11.2
+jupyter-client==6.1.6
+jupyter-core==4.6.3
+Keras==2.4.3
+Keras-Preprocessing==1.1.2
+lazy-object-proxy==1.4.3
+Markdown==3.2.2
+MarkupSafe==1.1.1
+mccabe==0.6.1
+numpy==1.19.1
+oauthlib==3.1.0
+opencv-python==4.3.0.36
+opt-einsum==3.3.0
+pandas==1.0.5
+parso==0.7.1
+pexpect==4.8.0
+pickleshare==0.7.5
+Pillow==7.2.0
+prompt-toolkit==3.0.5
+protobuf==3.12.2
+ptyprocess==0.6.0
+pyasn1==0.4.8
+pyasn1-modules==0.2.8
+Pygments==2.6.1
+pylint==2.5.3
+PySocks==1.7.1
+python-dateutil==2.8.1
+pytz==2020.1
+PyYAML==5.3.1
+pyzmq==19.0.1
+requests==2.24.0
+requests-oauthlib==1.3.0
+rsa==4.6
+scipy==1.4.1
+six==1.15.0
+tensorboard==2.2.2
+tensorboard-plugin-wit==1.7.0
+tensorflow==2.2.0
+tensorflow-estimator==2.2.0
+termcolor==1.1.0
+toml==0.10.1
+tornado==6.0.4
+tqdm==4.48.0
+traitlets==4.3.3
+typed-ast==1.4.1
+urllib3==1.25.10
+wcwidth==0.2.5
+Werkzeug==1.0.1
+wrapt==1.12.1
+zipp==3.1.0