insightface_pytorch

To capture a face image using your camera for the facebank:

1. Ensure you have downloaded the desired weights to the model folder.
2. Run the capture script with a name flag:

python take_pic.py -n name

Press q to take the picture. The script will capture only the single highest-probability face if multiple people are present.

3. To start the verification process, run:

python face_verify.py

To train the models, you need to prepare the dataset (e.g., the emore dataset).

1. Download and unzip the dataset files into the data path.
2. Run the preparation script to organize the files:

python prepare_data.py

After execution, the faces_emore/ directory will contain subfolders like agedb_30, calfw, cfp_ff, cfp_fp, cplfw, imgs, lfw, and vgg2_fp.

To perform face detection and verification over a camera or video, you must set up a face_bank directory. The system uses the folder structure to identify unique IDs. If a folder contains multiple images, the system will calculate an average embedding for that ID.

Required structure:

data/facebank/
        ---> id1/
            ---> id1_1.jpg
        ---> id2/
            ---> id2_1.jpg
        ---> id3/
            ---> id3_1.jpg
           ---> id3_2.jpg

To run inference on a video file, use the infer_on_video.py script. Note that the video file must be located inside the data/face_bank folder.

python infer_on_video.py -f [video file name] -s [save file name]

To use this project, clone the repository to your local machine:

git clone https://github.com/TropComplique/mtcnn-pytorch.git

Ensure you have the following dependencies installed to use the MTCNN implementation:

• pytorch (version 0.2 or compatible)
• Pillow
• numpy

To perform face detection using this MTCNN implementation, use the detect_faces function from the src module. This function accepts a PIL Image object and returns the detected bounding boxes and facial landmarks.

Returns:

• bounding_boxes: The coordinates of the detected faces.
• landmarks: The facial landmark points for each detected face.

from src import detect_faces
from PIL import Image

image = Image.open('image.jpg')
bounding_boxes, landmarks = detect_faces(image)

You can train the models using the train.py script with the following arguments:

• -b [batch_size]: Set the batch size.
• -lr [learning rate]: Set the learning rate.
• -e [epochs]: Set the number of epochs.

Example command for training MobileFacenet:

python train.py -net mobilefacenet -b 200 -w 4

python train.py -b [batch_size] -lr [learning rate] -e [epochs]

# Example:
python train.py -net mobilefacenet -b 200 -w 4

If your dataset is stored in MXNet RecordIO format (.rec and .idx), you can use mxnet.recordio.MXIndexedRecordIO to read specific images by index. The process involves:

1. Opening the recordio file.
2. Reading the indexed record.
3. Unpacking the header and image bytes.
4. Converting the bytes into a PIL Image object.

import mxnet as mx
import io
from PIL import Image
from pathlib import Path

face_folder = Path('/path/to/dataset')
bin_path = face_folder/'train.rec'
idx_path = face_folder/'train.idx'

# Open the recordio file
imgrec = mx.recordio.MXIndexedRecordIO(str(idx_path), str(bin_path), 'r')

# Read an image by index
img_info = imgrec.read_idx(813)
header, img = mx.recordio.unpack(img_info)

# Convert to PIL Image
encoded_jpg_io = io.BytesIO(img)
image = Image.open(encoded_jpg_io)

To use the MobileFaceNet architecture instead of the default, update the use_mobilfacenet flag in your configuration object before initializing the face_learner.

conf.use_mobilfacenet = True
learner = face_learner(conf, inference=True)
learner.load_state(conf, 'mobilefacenet.pth', True, True)

Use cvt_tform_mat_for_cv2 to convert a standard 3x3 affine transform matrix into the 2x3 matrix format required by cv2.warpAffine().

Parameters:

• trans: 3x3 np.array (the transform matrix).

Returns:

• cv2_trans: 2x3 np.array.