Computer Vision et Deep Learning : Les coulisses de SCARFACE

import cv2
from mtcnn import MTCNN

detector = MTCNN()

def detect_faces(frame):
    # Conversion RGB
    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

    # Détection
    faces = detector.detect_faces(rgb_frame)

    return faces

from tensorflow.keras.models import load_model
import numpy as np

facenet_model = load_model('facenet_keras.h5')

def get_face_embedding(face_image):
    # Resize 160x160 (requis par FaceNet)
    face_pixels = cv2.resize(face_image, (160, 160))

    # Normalisation
    face_pixels = face_pixels.astype('float32')
    mean, std = face_pixels.mean(), face_pixels.std()
    face_pixels = (face_pixels - mean) / std

    # Expansion pour batch
    samples = np.expand_dims(face_pixels, axis=0)

    # Embedding
    embedding = facenet_model.predict(samples)[0]

    return embedding

from scipy.spatial.distance import cosine

def find_match(embedding, database_embeddings, threshold=0.6):
    min_distance = float('inf')
    matched_person = None

    for person_id, db_embedding in database_embeddings.items():
        distance = cosine(embedding, db_embedding)

        if distance < min_distance:
            min_distance = distance
            matched_person = person_id

    if min_distance < threshold:
        return matched_person, 1 - min_distance  # Confidence

    return None, 0

import pytesseract
from PIL import Image

def extract_id_info(id_card_image):
    # Preprocessing
    gray = cv2.cvtColor(id_card_image, cv2.COLOR_BGR2GRAY)
    denoised = cv2.fastNlMeansDenoising(gray)

    # OCR
    text = pytesseract.image_to_string(denoised, lang='fra')

    # Extraction structurée avec regex
    patterns = {
        'numero': r'N°\s*([A-Z0-9]+)',
        'nom': r'Nom\s*:\s*([A-Z\s]+)',
        'prenom': r'Prénom\s*:\s*([A-Z\s]+)',
        'date_naissance': r'(\d{2}/\d{2}/\d{4})'
    }

    extracted = {}
    for key, pattern in patterns.items():
        match = re.search(pattern, text)
        if match:
            extracted[key] = match.group(1)

    return extracted

import tensorflow as tf

# Configuration GPU
gpus = tf.config.list_physical_devices('GPU')
if gpus:
    tf.config.experimental.set_memory_growth(gpus[0], True)

    # Mixed precision pour x2 performance
    policy = tf.keras.mixed_precision.Policy('mixed_float16')
    tf.keras.mixed_precision.set_global_policy(policy)

def process_batch(faces, batch_size=32):
    embeddings = []

    for i in range(0, len(faces), batch_size):
        batch = faces[i:i+batch_size]
        batch_embeddings = facenet_model.predict(np.array(batch))
        embeddings.extend(batch_embeddings)

    return embeddings