在Python-Django中为上传图片生成唯一键用于人脸识别验证的方法

Hey there! Let's walk through how to build this feature for your Django-based face recognition fraud detection system step by step. I'll cover model design, unique key generation, image upload handling, and verification logic—all tailored to your needs.

1. Design Your Django Model #

First, we need a model to store the image data (or reference to it) and the unique key. UUIDs are perfect for unique identifiers because they're practically collision-proof, but I'll also show a custom alternative if you prefer.

Option 1: Use UUID for Unique Key (Recommended)

This is the simplest and most reliable approach. We'll either store the image as binary data directly in the database, or save it to your file system and store the path (the latter is better for performance with large datasets).

from django.db import models
import uuid
from PIL import Image

class FaceImage(models.Model):
    # Auto-generate a unique UUID as the primary key
    unique_key = models.UUIDField(
        primary_key=True,
        default=uuid.uuid4,
        editable=False
    )
    
    # Choose ONE of these two image fields:
    # Option A: Store image binary directly in the database
    image_data = models.BinaryField()
    # Option B: Store image in media directory (better for scalability)
    # image = models.ImageField(upload_to='face_images/')
    
    uploaded_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f"Face Record - {self.unique_key}"

Option 2: Custom Unique Key Generation

If you want a shorter, human-readable key instead of a UUID, use a cryptographically secure random string:

import secrets
import string

def generate_custom_unique_key():
    # Generate a 16-character alphanumeric key
    chars = string.ascii_uppercase + string.digits
    return ''.join(secrets.choice(chars) for _ in range(16))

# Update the model field:
unique_key = models.CharField(
    max_length=16,
    unique=True,
    default=generate_custom_unique_key,
    editable=False
)

2. Handle Image Uploads in a View #

Next, create a view to accept uploaded images, process them, and save them to the database along with the unique key. Here's a function-based example (you can adapt this to class-based views too):

from django.shortcuts import render
from django.http import JsonResponse
from .models import FaceImage
from PIL import Image
import io

def upload_face_image(request):
    if request.method == 'POST' and request.FILES.get('image'):
        image_file = request.FILES['image']
        
        # If using BinaryField (storing image in DB):
        img = Image.open(image_file)
        img_byte_arr = io.BytesIO()
        # Preserve original format or force JPG for consistency
        img_format = image_file.content_type.split('/')[-1].upper()
        img.save(img_byte_arr, format=img_format)
        img_data = img_byte_arr.getvalue()
        
        # Create and save the record (unique key auto-generates)
        face_record = FaceImage(image_data=img_data)
        # If using ImageField instead: face_record = FaceImage(image=image_file)
        face_record.save()
        
        # Return the unique key to the frontend for later verification
        return JsonResponse({
            'status': 'success',
            'unique_key': str(face_record.unique_key)
        })
    
    return JsonResponse({'status': 'error', 'message': 'Invalid request or missing image'})

3. Implement Verification with the Unique Key #

When you need to verify a face, use the unique key to fetch the stored image and compare it against the new verification image. Here's how that view might look:

def verify_face(request):
    if request.method == 'POST':
        unique_key = request.POST.get('unique_key')
        verify_image = request.FILES.get('verify_image')
        
        if not unique_key or not verify_image:
            return JsonResponse({'status': 'error', 'message': 'Missing unique key or verification image'})
        
        try:
            # Fetch the stored record using the unique key
            stored_record = FaceImage.objects.get(unique_key=unique_key)
            
            # Process stored image (adjust based on your model's image field)
            if hasattr(stored_record, 'image_data'):
                stored_img = Image.open(io.BytesIO(stored_record.image_data))
            else:
                stored_img = Image.open(stored_record.image.path)
            
            # Process verification image
            verify_img = Image.open(verify_image)
            
            # Replace this with your actual face recognition logic
            # Example using face_recognition library:
            # stored_encoding = face_recognition.face_encodings(stored_img)[0]
            # verify_encoding = face_recognition.face_encodings(verify_img)[0]
            # is_match = face_recognition.compare_faces([stored_encoding], verify_encoding)[0]
            
            # For demonstration, we'll use a placeholder value
            is_match = False
            
            return JsonResponse({
                'status': 'success',
                'is_match': is_match,
                'message': 'Face matched successfully' if is_match else 'Face does not match'
            })
        
        except FaceImage.DoesNotExist:
            return JsonResponse({'status': 'error', 'message': 'Unique key not found in records'})
    
    return JsonResponse({'status': 'error', 'message': 'Invalid request method'})

4. Wire Up Your URLs #

Add these routes to your app's urls.py to make the endpoints accessible:

from django.urls import path
from . import views

urlpatterns = [
    path('face/upload/', views.upload_face_image, name='upload_face'),
    path('face/verify/', views.verify_face, name='verify_face'),
]

Quick Optimization Tips #

• Performance: Storing images in the database can slow down queries as your dataset grows. For large-scale systems, stick with ImageField (storing files in your media directory) and only save the unique key and file path in the database.
• Image Preprocessing: Resize or compress images before saving to reduce storage usage (e.g., img = img.resize((500, 500))).
• Security: Add authentication to your upload/verify endpoints (e.g., Django's LoginRequiredMixin or API tokens) to prevent unauthorized access.

内容的提问来源于stack exchange，提问作者vaishali malik