Spaces:
Runtime error
Runtime error
| from deepface import DeepFace | |
| from deepface.detectors import FaceDetector, OpenCvWrapper | |
| from deepface.extendedmodels import Emotion | |
| import cv2 | |
| import deepface.commons.functions | |
| import numpy | |
| import opennsfw2 | |
| class Emotion: | |
| labels = [emotion.capitalize() for emotion in Emotion.labels] | |
| model = DeepFace.build_model('Emotion') | |
| class NSFW: | |
| labels = [False, True] | |
| model = opennsfw2.make_open_nsfw_model() | |
| ################################################################################ | |
| class Pixels(numpy.ndarray): | |
| def read(cls, path): | |
| return cv2.imread(path).view(type=cls) | |
| def write(self, path): | |
| cv2.imwrite(path, self) | |
| class FaceImage(Pixels): | |
| def analyze(face_img): | |
| face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2GRAY) | |
| face_img = cv2.resize(face_img, (48, 48)) | |
| face_img = numpy.expand_dims(face_img, axis=0) | |
| predictions = Emotion.model.predict(face_img).ravel() | |
| return Emotion.labels[numpy.argmax(predictions)] | |
| def represent(face_img): | |
| face_img = numpy.expand_dims(face_img, axis=0) | |
| return DeepFace.represent(face_img, | |
| 'VGG-Face', | |
| detector_backend='skip')[0]['embedding'] | |
| class Image(Pixels): | |
| def annotate(img, face, emotion): | |
| face_annotation = numpy.zeros_like(img) | |
| face_annotation = cv2.cvtColor(face_annotation, | |
| cv2.COLOR_BGR2GRAY).view(type=Pixels) | |
| x, y, w, h = face | |
| axes = (int(0.1 * w), int(0.1 * h)) | |
| cv2.ellipse(face_annotation, (x + axes[0], y + axes[1]), axes, 180, 0, | |
| 90, (1, 0, 0), 2) | |
| cv2.ellipse(face_annotation, (x + w - axes[0], y + axes[1]), axes, 270, | |
| 0, 90, (1, 0, 0), 2) | |
| cv2.ellipse(face_annotation, (x + axes[0], y + h - axes[1]), axes, 90, | |
| 0, 90, (1, 0, 0), 2) | |
| cv2.ellipse(face_annotation, (x + w - axes[0], y + h - axes[1]), axes, | |
| 0, 0, 90, (1, 0, 0), 2) | |
| emotion_annotation = numpy.zeros_like(img) | |
| emotion_annotation = cv2.cvtColor(emotion_annotation, | |
| cv2.COLOR_BGR2GRAY).view(type=Pixels) | |
| for fontScale in numpy.arange(10, 0, -0.1): | |
| textSize, _ = cv2.getTextSize(emotion, cv2.FONT_HERSHEY_SIMPLEX, | |
| fontScale, 2) | |
| if textSize[0] <= int(0.6 * w): | |
| break | |
| cv2.putText(emotion_annotation, emotion, | |
| (int(x + (w - textSize[0]) / 2), int(y + textSize[1] / 2)), | |
| cv2.FONT_HERSHEY_SIMPLEX, fontScale, (1, 0, 0), 2) | |
| return [(face_annotation, 'face'), (emotion_annotation, 'emotion')] | |
| def detect_faces(img): | |
| face_detector = FaceDetector.build_model('opencv') | |
| faces = [] | |
| for _, face, _ in FaceDetector.detect_faces(face_detector, 'opencv', | |
| img, False): | |
| face = (int(face[0]), int(face[1]), int(face[2]), int(face[3])) | |
| faces.append(face) | |
| return faces | |
| def extract_face(img, face): | |
| face_detector = FaceDetector.build_model('opencv') | |
| x, y, w, h = face | |
| img = img[y:y + h, x:x + w] | |
| img = OpenCvWrapper.align_face(face_detector['eye_detector'], img) | |
| target_size = deepface.commons.functions.find_target_size('VGG-Face') | |
| face_img, _, _ = deepface.commons.functions.extract_faces( | |
| img, target_size, 'skip')[0] | |
| face_img = numpy.squeeze(face_img, axis=0) | |
| return face_img.view(type=FaceImage) | |
| def nsfw(img): | |
| img = cv2.resize(img, (224, 224)) | |
| img = img - numpy.array([104, 117, 123], numpy.float32) | |
| img = numpy.expand_dims(img, axis=0) | |
| predictions = NSFW.model.predict(img).ravel() | |
| return NSFW.labels[numpy.argmax(predictions)] | |
| def pixelate(img): | |
| h, w, _ = img.shape | |
| img = cv2.resize(img, (16, 16)) | |
| return cv2.resize(img, (w, h), | |
| interpolation=cv2.INTER_NEAREST).view(type=Pixels) | |
| ################################################################################ | |
| class Metadata(dict): | |
| def __init__(self, img): | |
| metadata = {} | |
| for face in img.detect_faces(): | |
| face_img = img.extract_face(face) | |
| emotion = face_img.analyze() | |
| representation = face_img.represent() | |
| metadata[face] = { | |
| 'emotion': emotion, | |
| 'representation': representation | |
| } | |
| super(Metadata, self).__init__(metadata) | |
| def emotions(self): | |
| return [value['emotion'] for value in self.values()] | |
| def representations(self): | |
| return [value['representation'] for value in self.values()] | |
| ################################################################################ | |
| def verify(source_representations, test_representations): | |
| for source_representation in source_representations: | |
| for test_representation in test_representations: | |
| if deepface.commons.distance.findCosineDistance( | |
| source_representation, test_representation | |
| ) < deepface.commons.distance.findThreshold('VGG-Face', 'cosine'): | |
| return True | |
| return False | |