import gradio as gr import numpy as np import cv2 import joblib from mtcnn import MTCNN from PIL import Image, ImageEnhance from keras_facenet import FaceNet # ------------------------------------------------------ # 1) Load your saved models model3 = joblib.load("model_general.pkl") # Approach 1 general model4 = joblib.load("model_male_1.pkl") # Male model #1 model6 = joblib.load("model_male_2.pkl") # Male model #2 model7 = joblib.load("model_female.pkl") # Female model # 2) Prepare face detection & embedding mtcnn_detector = MTCNN() facenet = FaceNet() # ------------------------------------------------------ # Helper functions def round_value(value): """Round numeric value to the nearest 0.05.""" return round(value * 20) / 20 def apply_augmentations(image_array): """ Given a numpy array (RGB), return a list of 5 augmented images (numpy arrays). We label them as: [flipped, bright_increase, bright_decrease, rotated_left, rotated_right]. """ augmentations = [] pil_img = Image.fromarray(image_array) # 1) Flip horizontally flipped = np.array(pil_img.transpose(Image.FLIP_LEFT_RIGHT)) augmentations.append(("flipped", flipped)) # 2) Brightness increase bright_increase = ImageEnhance.Brightness(pil_img).enhance(1.3) augmentations.append(("bright_up", np.array(bright_increase))) # 3) Brightness decrease bright_decrease = ImageEnhance.Brightness(pil_img).enhance(0.7) augmentations.append(("bright_down", np.array(bright_decrease))) # 4) Rotate left (+10 deg) rotated_left = pil_img.rotate(10, expand=False) # expand=False to keep same size augmentations.append(("rot_left", np.array(rotated_left))) # 5) Rotate right (-10 deg) rotated_right = pil_img.rotate(-10, expand=False) augmentations.append(("rot_right", np.array(rotated_right))) return augmentations def crop_largest_face(image_array): """ Use MTCNN to detect faces, and return the cropped region of the biggest face. If no faces found, return None. """ # MTCNN expects RGB image faces = mtcnn_detector.detect_faces(image_array) if len(faces) == 0: return None # find face with largest area largest_face = max(faces, key=lambda face: face['box'][2] * face['box'][3]) x, y, w, h = largest_face['box'] # clip to ensure we don't go out of bounds height, width = image_array.shape[:2] x1, y1 = max(x, 0), max(y, 0) x2, y2 = min(x + w, width), min(y + h, height) return image_array[y1:y2, x1:x2] def get_embedding(image_array): """ Convert single face (RGB) to embedding using keras-facenet. The .embeddings() method expects a list of arrays. Returns 512-dim embedding (np.array). """ # FaceNet wants images in [RGB], shape ~ (H, W, 3). # We'll assume each image is properly cropped around the face. # If needed, you might have to resize to (160,160). But FaceNet from keras-facenet # often does it internally. We'll pass as is. emb = facenet.embeddings([image_array])[0] # shape (512,) return emb def prepare_input_for_model(model, embedding, gender): """ If the model expects 513 features, prepend the gender flag (1 for male, 0 for female). Otherwise, just return the 512-dim embedding. """ if model.n_features_in_ == 513: gender_flag = 1 if gender.lower().startswith("m") else 0 arr = np.concatenate(([gender_flag], embedding)) return arr.reshape(1, -1) else: return embedding.reshape(1, -1) # ------------------------------------------------------ # Main pipeline function def process_images(img_paths, gender): """ - gender: "Male" or "Female" - img_paths: list of image file paths uploaded by user Returns a string with final result or error messages. """ # 1) Verify each image has at least one face images_list = [] no_face_indices = [] for idx, path in enumerate(img_paths): # read with cv2 image_bgr = cv2.imread(path[0]) if image_bgr is None: no_face_indices.append(idx) continue # convert BGR -> RGB image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB) # check face faces = mtcnn_detector.detect_faces(image_rgb) if len(faces) == 0: no_face_indices.append(idx) else: # store valid image images_list.append((idx, image_rgb)) # if ANY image had no face, report it and stop if no_face_indices: msg_lines = [] for bad_i in no_face_indices: msg_lines.append(f"Image {bad_i+1} has no detected face.") msg_lines.append("Please try again with different images.") return "\n".join(msg_lines) # 2) For each valid image, create 5 augmentations + original # We'll gather them in a structure: { idx: [(aug_label, image_array), ...], ... } # so that each input image has 6 versions. all_aug_images = {} # key = input_idx, value = list of (aug_label, np_array) for idx, orig_rgb in images_list: temp = [] temp.append(("original", orig_rgb)) # augment aug_list = apply_augmentations(orig_rgb) temp.extend(aug_list) # now we have 6 total all_aug_images[idx] = temp # 3) Crop largest face in each augmented image. If no face found => skip that augmentation # We'll keep them in { idx: { aug_label: [embedding arrays], ... }, ... } # Actually we want a single embedding per augmented image, so we'll store that. # Then we can average later by augmentation type across all input images. # That means for each input_idx, for each "aug_label", we get a single embedding, or None if no face. # We'll store per augmentation label across all images, so we can average them later: # label_embeds_map = { 'original': [], 'flipped': [], ... } label_embeds_map = {} for idx, aug_images in all_aug_images.items(): # aug_images is a list of (aug_label, np_array) for that input for aug_label, aug_img in aug_images: cropped = crop_largest_face(aug_img) if cropped is None: # skip continue # get embedding emb = get_embedding(cropped) if aug_label not in label_embeds_map: label_embeds_map[aug_label] = [] label_embeds_map[aug_label].append(emb) # 4) Now we have up to 6 keys in label_embeds_map: [original, flipped, bright_up, bright_down, rot_left, rot_right]. # Some may have fewer if some faces were not found in augmented versions. # We'll compute average embedding for each label if it has at least 1 embedding. final_label_embeddings = {} # label -> (512,) average for label, embed_list in label_embeds_map.items(): if len(embed_list) == 0: continue avg_emb = np.mean(embed_list, axis=0) final_label_embeddings[label] = avg_emb # If *none* of the 6 augmentations ended up with a face, we can't proceed if len(final_label_embeddings) == 0: return "No faces found in augmented images. Cannot proceed." # 5) For each label's average embedding, compute: # - Approach1 => model3.predict # - Approach2 => depends on gender: # male => average( model4.predict, model6.predict ) # female => model7.predict # - Hybrid => 0.5*(Approach1 + Approach2) # Then we'll store them in a list so we can average across labels at the end. approach3_results = [] # We'll store the final "hybrid" predictions for each label for label, emb in final_label_embeddings.items(): emb_2d = prepare_input_for_model(model3, emb, gender) pred_a1 = model3.predict(emb_2d)[0] emb_2d_4 = prepare_input_for_model(model4, emb, gender) p4 = model4.predict(emb_2d_4)[0] emb_2d_6 = prepare_input_for_model(model6, emb, gender) p6 = model6.predict(emb_2d_6)[0] emb_2d_7 = prepare_input_for_model(model7, emb, gender) pred_a2 = model7.predict(emb_2d_7)[0] # Approach 1 pred_a1 = model3.predict(emb_2d)[0] # Approach 2 if gender.lower().startswith("m"): # male => average of model4 + model6 p4 = model4.predict(emb_2d_4)[0] p6 = model6.predict(emb_2d_6)[0] pred_a2 = 0.5 * (p4 + p6) else: # female => model7 alone pred_a2 = model7.predict(emb_2d_7)[0] # Approach 3 => average(approach1, approach2) pred_a3 = 0.5 * (pred_a1 + pred_a2) # We'll store the final approach 3 result approach3_results.append(pred_a3) # 6) Average across all labels (the different augmentations) if len(approach3_results) == 0: return "No valid augmented faces after cropping; cannot proceed." final_score = np.mean(approach3_results) # Round to nearest quarter final_score = round_value(final_score) # clamp or keep it? The instructions say "X out of 10" # We'll do a simple float formatting # ... after computing final_score_quarter ... score = final_score # just to shorten variable name # Determine a descriptive message based on the user's intervals if score <= 3.0: message = "very unattractive and significantly below average" elif score <= 4.0: message = "very below average" elif score <= 4.5: message = "below average" elif score < 5.0: # Covers up to 4.75 or 4.99, etc. message = "slightly below average" elif score == 5.0: message = "average" elif score < 6.0: # Covers 5.25, 5.5, 5.75, etc. message = "decent and slightly above average" elif score <= 6.25: message = "good and decently above average" elif score < 6.5: # Covers 6.3, 6.4, etc. message = "very attractive and well above average" elif score == 6.5: message = "very attractive and well above average" elif score < 6.75: # Covers 6.6, 6.7 message = "very attractive and well above average" elif score <= 7.5: message = "highly attractive and very well above average" elif score < 7.75: # Covers e.g. 7.6 message = "highly attractive and very well above average" elif score == 7.75: message = "very attractive and significantly above average" elif score < 8.0: # Covers e.g. 7.8 message = "very attractive and significantly above average" elif score <= 8.5: message = "extremely amazing and very attractive" elif score < 8.75: message = "extremely amazing and very attractive" elif score <= 9.25: message = "extremely amazing and one of the best faces in the world" elif score < 9.5: message = "extremely amazing and one of the best faces in the world" else: # >= 9.5 message = "extremely amazing and one of the best faces ever created" # Now include that message in the final string return f"This person is {score} out of 10 in looks, which is {message}." interface = gr.Interface( fn=process_images, inputs=[ gr.Gallery(label="Upload Images", type='filepath'), gr.Radio(["Male", "Female"], label="Gender") ], outputs=gr.Textbox(label="Result"), title="How Attractive Are You?", description=( "**Upload a photo (or multiple photos) and see how high you score out of 10.**\n\n" "• Please ensure the image is well-lit and only shows your face, if possible.\n" " (We automatically crop to the largest face, but it’s best to avoid extra faces.)\n\n" "• The model can work with a single image, but **3–5 images** may yield a more accurate score.\n\n" "• This tool focuses on **facial symmetry**—it does **not** account for personal preferences or other factors.\n" " Please don’t take the result too seriously!\n\n" "• This model was trained on faces of people from age 20-50 so don't expect reasonable scores for outside this range.\n\n" "*If you’re curious about how this was made or the standards used, you can visit my kaggle notebook [here](https://www.kaggle.com/code/murtadhanajim/facial-attractiveness).*" ) ) interface.launch()