|
|
|
import gradio as gr |
|
import numpy as np |
|
from PIL import Image |
|
from transformers import AutoImageProcessor, AutoModel |
|
import torch |
|
|
|
|
|
import timm |
|
import torch.nn.functional as F |
|
from torchvision import transforms |
|
import time |
|
|
|
|
|
import subprocess |
|
import os |
|
|
|
|
|
from facenet_pytorch import MTCNN |
|
|
|
mtcnn = MTCNN(keep_all=False) |
|
|
|
|
|
|
|
def crop_face_to_112x112(image: Image.Image): |
|
if image.size == (112, 112): |
|
return image |
|
|
|
boxes, _ = mtcnn.detect(image) |
|
|
|
if boxes is None: |
|
raise ValueError("No face detected.") |
|
|
|
x1, y1, x2, y2 = map(int, boxes[0]) |
|
cropped = image.crop((x1, y1, x2, y2)) |
|
resized = cropped.resize((112, 112), Image.BILINEAR) |
|
return resized |
|
|
|
|
|
|
|
|
|
SECURITYLEVELS = ["128", "196", "256"] |
|
|
|
FRMODELS = ["gaunernst/vit_tiny_patch8_112.arcface_ms1mv3", |
|
"gaunernst/vit_tiny_patch8_112.cosface_ms1mv3"] |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def runBinFile(*args): |
|
binary_path = args[0] |
|
if not os.path.isfile(binary_path): |
|
return "Error: Compiled binary not Match." |
|
try: |
|
os.chmod(binary_path, 0o755) |
|
start = time.time() |
|
result = subprocess.run( |
|
list(args), |
|
stdout=subprocess.PIPE, |
|
stderr=subprocess.PIPE, |
|
text=True |
|
) |
|
end = time.time() |
|
duration = (end - start) * 1000 |
|
if 'print' in args: |
|
return result.stdout |
|
elif 'styledPrint' in args: |
|
return styled_output(result.stdout) |
|
elif result.returncode == 0: |
|
return True, f"<b>⏱️ Processing Time:</b> {duration:.0f} ms" |
|
else: |
|
return False |
|
except Exception as e: |
|
return f"Execution failed: {e}" |
|
|
|
|
|
example_images = ['./VGGFace2/n000001/0002_01.jpg', |
|
'./VGGFace2/n000149/0002_01.jpg', |
|
'./VGGFace2/n000082/0001_02.jpg', |
|
'./VGGFace2/n000148/0014_01.jpg', |
|
'./VGGFace2/n000129/0001_01.jpg', |
|
'./VGGFace2/n000394/0007_01.jpg', |
|
] |
|
|
|
example_images_auth = ['./VGGFace2/n000001/0013_01.jpg', |
|
'./VGGFace2/n000149/0019_01.jpg', |
|
'./VGGFace2/n000082/0003_03.jpg', |
|
'./VGGFace2/n000148/0043_01.jpg', |
|
'./VGGFace2/n000129/0006_01.jpg', |
|
'./VGGFace2/n000394/0018_01.jpg', |
|
] |
|
|
|
|
|
def display_image(image): |
|
return image |
|
|
|
|
|
def load_rec_image(): |
|
return f'static/reconstructed.png' |
|
|
|
|
|
def extract_emb(image, modelName=FRMODELS[0], mode=None): |
|
transform = transforms.Compose([ |
|
transforms.ToTensor(), |
|
transforms.RandomHorizontalFlip(), |
|
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]), |
|
]) |
|
image = transform(image) |
|
image = image.unsqueeze(0) |
|
|
|
model = timm.create_model(f"hf_hub:{modelName}", pretrained=True).eval() |
|
with torch.no_grad(): |
|
embs = model(image) |
|
embs = F.normalize(embs, dim=1) |
|
embs = embs.detach().numpy() |
|
embs = embs.squeeze(0) |
|
if mode != None: |
|
np.savetxt(f'{mode}-emb.txt', embs.reshape(1, embs.shape[0]), fmt="%.6f", delimiter=',') |
|
return embs |
|
|
|
def get_selected_image(evt: gr.SelectData): |
|
return example_images[evt.index] |
|
|
|
def get_selected_image_auth(evt: gr.SelectData): |
|
return example_images_auth[evt.index] |
|
|
|
|
|
def styled_output(result): |
|
if result.strip().lower() == "match": |
|
return "<span style='color: green; font-weight: bold;'>✔️ Match</span>" |
|
elif result.strip().lower() == "no match": |
|
return "<span style='color: red; font-weight: bold;'>❌ No Match</span>" |
|
else: |
|
return "<span style='color: red; font-weight: bold;'>Error</span>" |
|
|
|
|
|
with gr.Blocks() as demo: |
|
gr.HTML( |
|
""" |
|
<h1 align="center">Suraksh.AI</h1> |
|
<p align="center"> |
|
<a href="https://suraksh-ai.vercel.app/"> https://suraksh-ai.vercel.app/</a> |
|
</p> |
|
""" |
|
) |
|
gr.Markdown("# Biometric verification (1:1 matching) Using Fully Homomorphic Encryption (FHE)") |
|
|
|
gr.HTML( |
|
""" |
|
<p>This demo shows <strong>Suraksh.AI's</strong> biometric verification solution under <strong>FHE</strong>.</p> |
|
<ul> |
|
<li><strong>Scenario 1</strong>: Verifying an enrolled subject. For this scenario, the reference and probe should be from the same subject. Expected outcome: <span style='color: green; font-weight: bold;'>✔️ Match</span></li> |
|
<li><strong>Scenario 2</strong>: Verifying an enrolled subject with high recognition threshold. For this scenario, the reference and probe should be from the same subject and increase the recognition threshold. Expected outcome: <span style='color: red; font-weight: bold;'>❌ No Match</span></li> |
|
<li><strong>Scenario 3</strong>: Verifying a non-enrolled subject. For this scenario, choose a probe not enrolled. Expected outcome: <span style='color: red; font-weight: bold;'>❌ No Match</span></li> |
|
<li><strong>Scenario 4</strong>: Verifying a non-enrolled subject with low recognition threshold. For this scenario, choose a probe not enrolled and lower the recognition threshold. Expected outcome: <span style='color: green; font-weight: bold;'>✔️ Match</span></li> |
|
</ul> |
|
""" |
|
) |
|
|
|
with gr.Row(): |
|
gr.Markdown("## Phase 1: Enrollment") |
|
with gr.Row(): |
|
gr.Markdown("### Step 1: Upload or select a reference facial image for enrollment.") |
|
with gr.Row(): |
|
image_input_enroll = gr.Image(type="pil", visible=False) |
|
with gr.Column(): |
|
image_upload_enroll = gr.Image(label="Upload a reference facial image.", type="pil", sources="upload") |
|
image_upload_enroll.change(fn=crop_face_to_112x112, inputs=image_upload_enroll, outputs=image_input_enroll) |
|
with gr.Column(): |
|
example_gallery = gr.Gallery(value=example_images, columns=3) |
|
example_gallery.select(fn=get_selected_image, inputs=None, outputs=image_input_enroll) |
|
with gr.Column(): |
|
selectedImage = gr.Image(type="pil", label="Reference facial image", interactive=False) |
|
image_input_enroll.change(fn=lambda img: img, inputs=image_input_enroll, outputs=selectedImage) |
|
|
|
with gr.Row(): |
|
gr.Markdown("### Step 2: Generate reference embedding.") |
|
with gr.Row(): |
|
with gr.Column(): |
|
modelName = gr.Dropdown( |
|
choices=FRMODELS, |
|
label="Choose a face recognition model" |
|
) |
|
with gr.Column(): |
|
example_gallery.select(fn=get_selected_image, inputs=None, outputs=image_input_enroll) |
|
key_button = gr.Button("Generate embedding") |
|
enroll_emb_text = gr.JSON(label="Reference embedding") |
|
mode = gr.State("enroll") |
|
key_button.click(fn=extract_emb, inputs=[image_input_enroll, modelName, mode], outputs=enroll_emb_text) |
|
|
|
|
|
with gr.Row(): |
|
gr.Markdown("""Facial embeddings are **INVERTIBLE** and lead to the **RECONSTRUCTION** of their raw facial images.""") |
|
with gr.Row(): |
|
gr.Markdown("### Example:") |
|
with gr.Row(): |
|
original_image = gr.Image(value="static/original.jpg", label="Original", sources="upload") |
|
key_button = gr.Button("Generate embedding") |
|
output_text = gr.JSON(label="Target embedding") |
|
key_button.click(fn=extract_emb, inputs=[original_image, modelName], outputs=output_text) |
|
btn = gr.Button("Reconstruct facial image") |
|
Reconstructed_image = gr.Image(label="Reconstructed") |
|
btn.click(fn=load_rec_image, outputs=Reconstructed_image) |
|
with gr.Row(): |
|
gr.Markdown("""Facial embeddings protection is a must! At **Suraksh.AI**, we protect facial embeddings using FHE.""") |
|
|
|
|
|
|
|
with gr.Row(): |
|
gr.Markdown("### Step 3: 🔐 Generate the FHE public and secret keys.") |
|
with gr.Row(): |
|
with gr.Column(): |
|
securityLevel = gr.Dropdown( |
|
choices=SECURITYLEVELS, |
|
label="Choose a security level" |
|
) |
|
with gr.Column(): |
|
key_button = gr.Button("Generate the FHE public and secret keys") |
|
key_status = gr.Checkbox(label="FHE Public and Secret keys generated.", value=False) |
|
time_output = gr.HTML() |
|
key_button.click(fn=runBinFile, inputs=[gr.State("./bin/genKeys.bin"), securityLevel, gr.State("genkeys")], outputs=[key_status,time_output]) |
|
|
|
|
|
with gr.Row(): |
|
gr.Markdown("### Step 4: 🔒 Encrypt reference embedding using FHE.") |
|
with gr.Row(): |
|
with gr.Column(): |
|
key_button = gr.Button("Encrypt") |
|
key_status = gr.Checkbox(label="Reference embedding encrypted.", value=False) |
|
time_output = gr.HTML() |
|
key_button.click(fn=runBinFile, inputs=[gr.State("./bin/encReference.bin"), securityLevel, gr.State("encrypt")], outputs=[key_status,time_output]) |
|
|
|
with gr.Column(): |
|
key_button = gr.Button("Display") |
|
output_text = gr.Text(label="Encrypted embedding", lines=3, interactive=False) |
|
key_button.click(fn=runBinFile, inputs=[gr.State("./bin/encReference.bin"), securityLevel, gr.State("print")], outputs=output_text) |
|
|
|
|
|
with gr.Row(): |
|
gr.Markdown("## Phase 2: Authentication") |
|
with gr.Row(): |
|
gr.Markdown("### Step 1: Upload or select a probe facial image for authentication.") |
|
with gr.Row(): |
|
selectedImagePath_auth = gr.State() |
|
image_input_auth = gr.Image(type="pil", visible=False) |
|
with gr.Column(): |
|
image_upload_auth = gr.Image(label="Upload a facial image.", type="pil", sources="upload") |
|
image_upload_auth.change(fn=crop_face_to_112x112, inputs=image_upload_auth, outputs=image_input_auth) |
|
with gr.Column(): |
|
example_gallery = gr.Gallery(value=example_images_auth, columns=3) |
|
example_gallery.select(fn=get_selected_image_auth, inputs=None, outputs=image_input_auth) |
|
with gr.Column(): |
|
selectedImage = gr.Image(type="pil", label="Probe facial image", interactive=False) |
|
image_input_auth.change(fn=lambda img: img, inputs=image_input_auth, outputs=selectedImage) |
|
|
|
with gr.Row(): |
|
gr.Markdown("### Step 2: Generate probe facial embedding.") |
|
with gr.Row(): |
|
with gr.Column(): |
|
example_gallery.select(fn=get_selected_image_auth, inputs=None, outputs=image_input_auth) |
|
key_button = gr.Button("Generate embedding") |
|
enroll_emb_text = gr.JSON(label="Probe embedding") |
|
mode = gr.State("auth") |
|
key_button.click(fn=extract_emb, inputs=[image_input_auth, modelName, mode], outputs=enroll_emb_text) |
|
with gr.Row(): |
|
gr.Markdown("### Step 3: 🔀 Generate protected probe embedding.") |
|
with gr.Row(): |
|
with gr.Column(): |
|
key_button = gr.Button("Protect") |
|
key_status = gr.Checkbox(label="Probe embedding protected.", value=False) |
|
time_output = gr.HTML() |
|
key_button.click(fn=runBinFile, inputs=[gr.State("./bin/encProbe.bin"), securityLevel, gr.State("encrypt")], outputs=[key_status,time_output]) |
|
with gr.Column(): |
|
key_button = gr.Button("Display") |
|
output_text = gr.Text(label="Protected embedding", lines=3, interactive=False) |
|
key_button.click(fn=runBinFile, inputs=[gr.State("./bin/encProbe.bin"), securityLevel, gr.State("print")], outputs=output_text) |
|
|
|
with gr.Row(): |
|
gr.Markdown("### Step 4: 🔒 Compute biometric recognition decision using the threshold under FHE.") |
|
with gr.Row(): |
|
gr.Markdown("### Set the recognition threshold.") |
|
with gr.Row(): |
|
slider_threshold = gr.Slider(-512*5, 512*5, step=1, value=133, label="Decision threshold", info="The higher the stricter.", interactive=True) |
|
number_threshold = gr.Textbox(visible=False, value = '133') |
|
slider_threshold.change(fn=lambda x: x, inputs=slider_threshold, outputs=number_threshold) |
|
with gr.Row(): |
|
with gr.Column(): |
|
key_button = gr.Button("Biometric recognition under FHE") |
|
key_status = gr.Checkbox(label="Recognition decision encrypted.", value=False) |
|
time_output = gr.HTML() |
|
key_button.click(fn=runBinFile, inputs=[gr.State("./bin/recDecision.bin"), securityLevel, gr.State("decision"), number_threshold], outputs=[key_status,time_output]) |
|
with gr.Column(): |
|
key_button = gr.Button("Display") |
|
output_text = gr.Text(label="Encrypted decision", lines=3, interactive=False) |
|
key_button.click(fn=runBinFile, inputs=[gr.State("./bin/recDecision.bin"), securityLevel, gr.State("print")], outputs=output_text) |
|
|
|
|
|
with gr.Row(): |
|
gr.Markdown("### Step 5: 🔑 Decrypt biometric recognition decision.") |
|
with gr.Row(): |
|
with gr.Column(scale=1): |
|
decision_button = gr.Button("Decrypt") |
|
decision_status = gr.Checkbox(label="Recognition decision decrypted.", value=False) |
|
time_output = gr.HTML() |
|
decision_button.click(fn=runBinFile, inputs=[gr.State("./bin/decDecision.bin"), securityLevel, gr.State("decision")], outputs=[decision_status, time_output]) |
|
with gr.Column(scale=3): |
|
with gr.Row(): |
|
check_button = gr.Button("Check") |
|
with gr.Row(): |
|
with gr.Column(scale=1): |
|
final_output = gr.HTML() |
|
check_button.click(fn=runBinFile, inputs=[gr.State("./bin/decDecision.bin"), securityLevel, gr.State("styledPrint")], outputs=final_output) |
|
with gr.Column(scale=1): |
|
image_output_enroll = gr.Image(label="Reference", sources="upload") |
|
image_input_enroll.change(fn=display_image, inputs=image_input_enroll, outputs=image_output_enroll) |
|
with gr.Column(scale=1): |
|
image_output_auth = gr.Image(label="Probe", sources="upload") |
|
image_input_auth.change(fn=display_image, inputs=image_input_auth, outputs=image_output_auth) |
|
|
|
|
|
|
|
demo.launch() |
|
|
