Face Recognition Pipeline Tutorial¶
1. Introduction to the Face Recognition Pipeline¶
Face recognition is a crucial component in the field of computer vision, aiming to automatically identify individuals by analyzing and comparing facial features. This task involves not only detecting faces in images but also extracting and matching facial features to find corresponding identity information in a database. Face recognition is widely used in security authentication, surveillance systems, social media, smart devices, and other scenarios.
The face recognition pipeline is an end-to-end system dedicated to solving face detection and recognition tasks. It can quickly and accurately locate face regions in images, extract facial features, and retrieve and compare them with pre-established features in a feature database to confirm identity information.
The face recognition pipeline includes a face detection module and a face feature module, with several models in each module. Which models to use can be selected based on the benchmark data below. If you prioritize model accuracy, choose models with higher accuracy; if you prioritize inference speed, choose models with faster inference; if you prioritize model size, choose models with smaller storage requirements.
Face Detection Module:
Model | Model Download Link | AP (%) Easy/Medium/Hard |
GPU Inference Time (ms) [Normal Mode / High-Performance Mode] |
CPU Inference Time (ms) [Normal Mode / High-Performance Mode] |
Model Size (M) | Description |
---|---|---|---|---|---|---|
BlazeFace | Inference Model/Trained Model | 77.7/73.4/49.5 | 60.34 / 54.76 | 84.18 / 84.18 | 0.447 | A lightweight and efficient face detection model |
BlazeFace-FPN-SSH | Inference Model/Trained Model | 83.2/80.5/60.5 | 69.29 / 63.42 | 86.96 / 86.96 | 0.606 | Improved BlazeFace with FPN and SSH structures |
PicoDet_LCNet_x2_5_face | Inference Model/Trained Model | 93.7/90.7/68.1 | 35.37 / 12.88 | 126.24 / 126.24 | 28.9 | Face detection model based on PicoDet_LCNet_x2_5 |
PP-YOLOE_plus-S_face | Inference Model/Trained Model | 93.9/91.8/79.8 | 22.54 / 8.33 | 138.67 / 138.67 | 26.5 | Face detection model based on PP-YOLOE_plus-S |
Face Recognition Module:
Model | Model Download Link | Output Feature Dimension | Acc (%) AgeDB-30/CFP-FP/LFW |
GPU Inference Time (ms) [Normal Mode / High-Performance Mode] |
CPU Inference Time (ms) [Normal Mode / High-Performance Mode] |
Model Size (M) | Description |
---|---|---|---|---|---|---|---|
MobileFaceNet | Inference Model/Trained Model | 128 | 96.28/96.71/99.58 | 5.7 | 101.6 | 4.1 | Face recognition model trained on MS1Mv3 based on MobileFaceNet |
ResNet50_face | Inference Model/Trained Model | 512 | 98.12/98.56/99.77 | 8.7 | 200.7 | 87.2 | Face recognition model trained on MS1Mv3 based on ResNet50 |
Test Environment Description:
- Performance Test Environment
- Test Dataset:
- Face Detection Model: Evaluated on the WIDER-FACE validation set in COCO format with an input size of 640*640.
- Face Feature Model: Evaluated on the AgeDB-30, CFP-FP, and LFW datasets, respectively.
-
Hardware Configuration:
- GPU: NVIDIA Tesla T4
- CPU: Intel Xeon Gold 6271C @ 2.60GHz
- Other Environments: Ubuntu 20.04 / cuDNN 8.6 / TensorRT 8.5.2.2
-
Inference Mode Description
Mode | GPU Configuration | CPU Configuration | Acceleration Technology Combination |
---|---|---|---|
Normal Mode | FP32 Precision / No TRT Acceleration | FP32 Precision / 8 Threads | PaddleInference |
High-Performance Mode | Optimal combination of pre-selected precision types and acceleration strategies | FP32 Precision / 8 Threads | Pre-selected optimal backend (Paddle/OpenVINO/TRT, etc.) |
2. Quick Start¶
The pre-trained model pipelines provided by PaddleX can be quickly experienced. You can experience the effects of the face recognition pipeline online or locally using command-line or Python.
2.1 Online Experience¶
Oneline Experience is not supported at the moment.
2.2 Local Experience¶
❗ Before using the face recognition pipeline locally, please ensure that you have completed the installation of the PaddleX wheel package according to the PaddleX Installation Guide.
2.2.1 Command Line Experience¶
Command line experience is not supported yet.
2.2.2 Python Script Integration¶
Please download the test image for testing. In the example run of this pipeline, you need to pre-build a face feature library. You can refer to the following instructions to download the official demo data for subsequent construction of the face feature library. You can refer to the following command to download the Demo dataset to the specified folder:
cd /path/to/paddlex
wget https://paddle-model-ecology.bj.bcebos.com/paddlex/data/face_demo_gallery.tar
tar -xf ./face_demo_gallery.tar
If you wish to build a facial feature library using your private dataset, you can refer to Section 2.3 Data Organization for Building Feature Libraries. After that, you can complete the establishment of the facial feature library and the fast inference of the facial recognition pipeline with just a few lines of code.
from paddlex import create_pipeline
pipeline = create_pipeline(pipeline="face_recognition")
index_data = pipeline.build_index(gallery_imgs="face_demo_gallery", gallery_label="face_demo_gallery/gallery.txt")
index_data.save("face_index")
output = pipeline.predict("friends1.jpg", index=index_data)
for res in output:
res.print()
res.save_to_img("./output/")
res.save_to_json("./output/")
In the above Python script, the following steps are performed:
(1) Call create_pipeline
to instantiate the face recognition pipeline object. The specific parameter descriptions are as follows:
Parameter | Description | Type | Default Value |
---|---|---|---|
pipeline |
The name of the pipeline or the path to the pipeline configuration file. If it is the name of the pipeline, it must be a pipeline supported by PaddleX. | str |
None |
config |
Specific configuration information for the pipeline (if set simultaneously with the pipeline , it takes precedence over the pipeline , and the pipeline name must match the pipeline ).
|
dict[str, Any] |
None |
device |
The inference device for the pipeline. Supports specifying the specific card number of the GPU, such as "gpu:0", the specific card number of other hardware, such as "npu:0", and CPU such as "cpu". | str |
gpu:0 |
use_hpip |
Whether to enable high-performance inference, available only when the pipeline supports high-performance inference. | bool |
False |
(2) Call the build_index
method of the face recognition pipeline object to build the face feature library. The specific parameter descriptions are as follows:
Parameter | Description | Type | Options | Default Value |
---|---|---|---|---|
gallery_imgs |
The base library images to be added, required parameter | str |list |
|
None |
gallery_label |
The annotation information of the base library images, required parameter | str|list |
|
None |
metric_type |
Feature measurement method, optional parameter | str |
|
"IP" |
index_type |
Index type, optional parameter | str |
|
"HNSW32" |
- The feature library object
index
supports thesave
method to save the feature library to disk:
Parameter | Description | Type | Default Value |
---|---|---|---|
save_path |
The save directory of the feature library file, such as drink_index . |
str |
None |
(3) Call the predict
method of the face recognition pipeline object for inference prediction: The parameter of the predict
method is input
, which is used to input the data to be predicted and supports multiple input methods. Specific examples are as follows:
Parameter | Description | Type | Options | Default |
---|---|---|---|---|
input |
Data to be predicted, supports multiple input types (required parameter) | Python Var|str|list |
|
None |
index |
The feature library used for pipeline inference prediction (optional parameter). If this parameter is not provided, the index library specified in the pipeline configuration file will be used by default. | str|paddlex.inference.components.retrieval.faiss.IndexData|None |
|
None |
(4) Process the prediction results: The prediction result of each sample is of dict
type and supports printing or saving to a file. The supported file types depend on the specific pipeline, such as:
Method | Description | Parameter | Type | Description | Default |
---|---|---|---|---|---|
print() |
Print the result to the terminal | format_json |
bool |
Whether to format the output content using JSON indentation |
True |
indent |
int |
Specify the indentation level to beautify the output JSON data, making it more readable. Effective only when format_json is True |
4 | ||
ensure_ascii |
bool |
Control whether to escape non-ASCII characters to Unicode . When set to True , all non-ASCII characters will be escaped; False will retain the original characters. Effective only when format_json is True |
False |
||
save_to_json() |
Save the result as a JSON file | save_path |
str |
Path to save the file. When it is a directory, the saved file name will be consistent with the input file type | None |
indent |
int |
Specify the indentation level to beautify the output JSON data, making it more readable. Effective only when format_json is True |
4 | ||
ensure_ascii |
bool |
Control whether to escape non-ASCII characters to Unicode . When set to True , all non-ASCII characters will be escaped; False will retain the original characters. Effective only when format_json is True |
False |
||
save_to_img() |
Save the result as an image file | save_path |
str |
Path to save the file, supports directory or file path | None |
- Calling the
print()
method will print the following result to the terminal:
{'res': {'input_path': 'friends1.jpg', 'boxes': [{'labels': ['Chandler', 'Chandler', 'Chandler', 'Chandler', 'Chandler'], 'rec_scores': [0.5884832143783569, 0.5777347087860107, 0.5082703828811646, 0.48792028427124023, 0.4842316806316376], 'det_score': 0.9119220972061157, 'coordinate': [790.40015, 170.34453, 868.47626, 279.54446]}, {'labels': ['Joey', 'Joey', 'Joey', 'Joey', 'Joey'], 'rec_scores': [0.5654032826423645, 0.5601680278778076, 0.5382657051086426, 0.5320160984992981, 0.5209866762161255], 'det_score': 0.9052104353904724, 'coordinate': [1274.6246, 184.58124, 1353.4016, 300.0643]}, {'labels': ['Phoebe', 'Phoebe', 'Phoebe', 'Phoebe', 'Phoebe'], 'rec_scores': [0.6462339162826538, 0.6003466844558716, 0.5999515652656555, 0.583031415939331, 0.5640993118286133], 'det_score': 0.9041699171066284, 'coordinate': [1052.4514, 192.52296, 1129.5226, 292.84177]}, {'labels': ['Ross', 'Ross', 'Ross', 'Ross', 'Ross'], 'rec_scores': [0.5012176036834717, 0.49081552028656006, 0.48970693349838257, 0.4808862805366516, 0.4794950783252716], 'det_score': 0.9031845331192017, 'coordinate': [162.41049, 156.96768, 242.07184, 266.13004]}, {'labels': ['Monica', 'Monica', 'Monica', 'Monica', 'Monica'], 'rec_scores': [0.5704089403152466, 0.5037636756896973, 0.4877302646636963, 0.46702104806900024, 0.4376206696033478], 'det_score': 0.8862134218215942, 'coordinate': [572.18176, 216.25815, 639.2387, 311.08417]}, {'labels': ['Rachel', 'Rachel', 'Rachel', 'Rachel', 'Rachel'], 'rec_scores': [0.6107711791992188, 0.5915063619613647, 0.5776835083961487, 0.569993257522583, 0.5594189167022705], 'det_score': 0.8822972774505615, 'coordinate': [303.12866, 231.94759, 374.5314, 330.2883]}]}}
-
The meanings of the output parameters are as follows:
input_path
: Indicates the path of the input image.boxes
: Information of detected faces, a list of dictionaries, each dictionary contains the following information:labels
: List of recognized labels, sorted by score from high to low.rec_scores
: List of recognition scores, where elements correspond tolabels
one by one.det_score
: Detection score.coordinate
: Coordinates of the face bounding box, in the format [xmin, ymin, xmax, ymax].
-
Calling the
save_to_json()
method will save the above content to the specifiedsave_path
. If a directory is specified, the saved path will besave_path/{your_img_basename}_res.json
. If a file is specified, it will be saved directly to that file. - Calling the
save_to_img()
method will save the visualization result to the specifiedsave_path
. If a directory is specified, the saved path will besave_path/{your_img_basename}_res.{your_img_extension}
. If a file is specified, it will be saved directly to that file. (The pipeline usually contains many result images; it is not recommended to specify a specific file path directly, otherwise multiple images will be overwritten, leaving only the last one.) In the example above, the visualization result is as follows:
- Additionally, it also supports obtaining the visualized image with results and prediction results through attributes, as follows:
Attribute | Description |
---|---|
json |
Get the prediction result in json format. |
img |
Get the visualized image in dict format. |
- The prediction result obtained by the
json
attribute is data of dict type, and the relevant content is consistent with the content saved by calling thesave_to_json()
method. - The prediction result returned by the
img
attribute is data of dict type. The key isres
, and the corresponding value is anImage.Image
object used to visualize the face recognition result.
The above Python script integration method uses the parameter settings in the PaddleX official configuration file by default. If you need to customize the configuration file, you can first execute the following command to obtain the official configuration file and save it in my_path
:
If you have obtained the configuration file, you can customize the settings for the face recognition pipeline. You just need to modify the pipeline
parameter value in the create_pipeline
method to the path of your custom pipeline configuration file.
For example, if your custom configuration file is saved in ./my_path/face_recognition.yaml
, you just need to execute:
from paddlex import create_pipeline
pipeline = create_pipeline(pipeline="./my_path/face_recognition.yaml")
output = pipeline.predict("friends1.jpg", index="face_index")
for res in output:
res.print()
res.save_to_json("./output/")
res.save_to_img("./output/")
Note: The parameters in the configuration file are the initialization parameters of the pipeline. If you wish to change the initialization parameters of the face recognition pipeline, you can directly modify the parameters in the configuration file and load the configuration file for prediction.
2.2.3 Adding and Deleting Operations in the Face Feature Library¶
If you wish to add more face images to the feature library, you can call the append_index
method; to delete face image features, you can call the remove_index
method.
from paddlex import create_pipeline
pipeline = create_pipeline(pipeline="face_recognition")
index_data = pipeline.build_index(gallery_imgs="face_demo_gallery", gallery_label="face_demo_gallery/gallery.txt", index_type="IVF", metric_type="IP")
index_data = pipeline.append_index(gallery_imgs="face_demo_gallery", gallery_label="face_demo_gallery/gallery.txt", index=index_data)
index_data = pipeline.remove_index(remove_ids="face_demo_gallery/remove_ids.txt", index=index_data)
index_data.save("face_index")
The parameters of the above method are described as follows:
Parameter | Description | Type | Options | Default Value |
---|---|---|---|---|
gallery_imgs |
Gallery images to be added, required parameter | str |list |
|
None |
gallery_label |
Labels for gallery images, required parameter | str|list |
|
None |
metric_type |
Feature measurement method, optional parameter | str |
|
"IP" |
index_type |
Type of index, optional parameter | str |
|
"HNSW32" |
remove_ids |
Indices to be removed | str |list |
|
None |
index |
Feature library used for pipeline inference | str|paddlex.inference.components.retrieval.faiss.IndexData |
|
None |
Note: HNSW32
has compatibility issues on the Windows platform, which may prevent the index library from being built or loaded.
2.3 Data Organization for Building the Feature Library¶
The face recognition pipeline example of PaddleX requires a pre-built feature library for face feature retrieval. If you wish to build a face feature library with your private data, you need to organize the data as follows:
data_root # Root directory of the dataset, the directory name can be changed
├── images # Directory for storing images, the directory name can be changed
│ ├── ID0 # Identity ID name, preferably a meaningful name, such as a person's name
│ │ ├── xxx.jpg # Image, nested levels are supported here
│ │ ├── xxx.jpg # Image, nested levels are supported here
│ │ ...
│ ├── ID1 # Identity ID name, preferably a meaningful name, such as a person's name
│ │ ├── xxx.jpg # Image, nested levels are supported here
│ │ ├── xxx.jpg # Image, nested levels are supported here
│ │ ...
│ ...
└── gallery.txt # Annotation file for the feature library dataset, the file name can be changed. Each line provides the path and label of the face image to be retrieved, separated by a space. Example content: images/Chandler/Chandler00037.jpg Chandler
3. Development Integration/Deployment¶
If the face recognition pipeline meets your requirements for inference speed and accuracy, you can proceed directly with development integration/deployment.
If you need to apply the face recognition pipeline directly in your Python project, you can refer to the example code in 2.2.2 Python Script Integration.
Additionally, PaddleX provides three other deployment methods, detailed as follows:
🚀 High-Performance Inference: In actual production environments, many applications have stringent standards for the performance metrics of deployment strategies (especially response speed) to ensure efficient system operation and smooth user experience. To this end, PaddleX offers a high-performance inference plugin aimed at deeply optimizing the performance of model inference and pre/post-processing, significantly speeding up the end-to-end process. For detailed high-performance inference processes, please refer to PaddleX High-Performance Inference Guide.
☁️ Service Deployment: Service deployment is a common form of deployment in actual production environments. By encapsulating the inference function as a service, clients can access these services via network requests to obtain inference results. PaddleX supports multiple pipeline service deployment schemes. For detailed pipeline service deployment processes, please refer to PaddleX Service Deployment Guide.
Below is the API reference for basic service deployment and multi-language service call examples:
API Reference
For the main operations provided by the service:
- The HTTP request method is POST.
- Both the request body and response body are JSON data (JSON objects).
- When the request is processed successfully, the response status code is
200
, and the properties of the response body are as follows:
Name | Type | Meaning |
---|---|---|
logId |
string |
The UUID of the request. |
errorCode |
integer |
Error code. Fixed at 0 . |
errorMsg |
string |
Error description. Fixed at "Success" . |
result |
object |
The result of the operation. |
- When the request is not processed successfully, the properties of the response body are as follows:
Name | Type | Meaning |
---|---|---|
logId |
string |
The UUID of the request. |
errorCode |
integer |
Error code. Same as the response status code. |
errorMsg |
string |
Error description. |
The main operations provided by the service are as follows:
buildIndex
Build feature vector index.
POST /face-recognition-index-build
- The properties of the request body are as follows:
Name | Type | Meaning | Required |
---|---|---|---|
imageLabelPairs |
array |
Image-label pairs used to build the index. | Yes |
Each element in imageLabelPairs
is an object
with the following properties:
Name | Type | Meaning |
---|---|---|
image |
string |
The URL of the image file accessible by the server or the Base64-encoded result of the image file content. |
label |
string |
Label. |
- When the request is processed successfully, the
result
in the response body has the following properties:
Name | Type | Meaning |
---|---|---|
indexKey |
string |
The key corresponding to the index, used to identify the created index. It can be used as input for other operations. |
imageCount |
integer |
The number of images indexed. |
addImagesToIndex
Add images (corresponding feature vectors) to the index.
POST /face-recognition-index-add
- The properties of the request body are as follows:
Name | Type | Description | Required |
---|---|---|---|
imageLabelPairs |
array |
Image-label pairs used to build the index. | Yes |
indexKey |
string |
The key corresponding to the index. Provided by the buildIndex operation. |
Yes |
Each element in imageLabelPairs
is an object
with the following properties:
Name | Type | Description |
---|---|---|
image |
string |
The URL of an image file accessible by the server or the Base64-encoded content of the image file. |
label |
string |
The label. |
- When the request is processed successfully, the
result
in the response body has the following properties:
Name | Type | Description |
---|---|---|
imageCount |
integer |
The number of images indexed. |
removeImagesFromIndex
Remove images (corresponding feature vectors) from the index.
POST /face-recognition-index-remove
- The properties of the request body are as follows:
Name | Type | Description | Required |
---|---|---|---|
ids |
array |
The IDs of the vectors to be removed from the index. | Yes |
indexKey |
string |
The key corresponding to the index. Provided by the buildIndex operation. |
Yes |
- When the request is processed successfully, the
result
in the response body has the following properties:
Name | Type | Description |
---|---|---|
imageCount |
integer |
The number of images indexed. |
infer
Perform image recognition.
POST /face-recognition-infer
- The properties of the request body are as follows:
Name | Type | Description | Required |
---|---|---|---|
image |
string |
The URL of an image file accessible by the server or the Base64-encoded content of the image file. | Yes |
indexKey |
string |
The key corresponding to the index. Provided by the buildIndex operation. |
No |
detThreshold |
number | null |
Refer to the det_threshold parameter description in the pipeline predict method. |
No |
recThreshold |
number | null |
Refer to the rec_threshold parameter description in the pipeline predict method. |
No |
hammingRadius |
number | null |
Refer to the hamming_radius parameter description in the pipeline predict method. |
No |
topk |
integer | null |
Refer to the topk parameter description in the pipeline predict method. |
No |
- When the request is processed successfully, the
result
in the response body has the following properties:
Name | Type | Description |
---|---|---|
faces |
array |
Information about detected faces. |
image |
string | null |
The recognition result image. The image is in JPEG format and is Base64-encoded. |
Each element in faces
is an object
with the following properties:
Name | Type | Description |
---|---|---|
bbox |
array |
The location of the face target. The elements of the array are the x-coordinate of the top-left corner, the y-coordinate of the top-left corner, the x-coordinate of the bottom-right corner, and the y-coordinate of the bottom-right corner. |
recResults |
array |
Recognition results. |
score |
number |
The detection score. |
Each element in recResults
is an object
with the following properties:
Name | Type | Description |
---|---|---|
label |
string |
The label. |
score |
number |
The recognition score. |
Multi-language Service Call Example
Python
import base64
import pprint
import sys
import requests
API_BASE_URL = "http://0.0.0.0:8080"
base_image_label_pairs = [
{"image": "./demo0.jpg", "label": "ID0"},
{"image": "./demo1.jpg", "label": "ID1"},
{"image": "./demo2.jpg", "label": "ID2"},
]
image_label_pairs_to_add = [
{"image": "./demo3.jpg", "label": "ID2"},
]
ids_to_remove = [1]
infer_image_path = "./demo4.jpg"
output_image_path = "./out.jpg"
for pair in base_image_label_pairs:
with open(pair["image"], "rb") as file:
image_bytes = file.read()
image_data = base64.b64encode(image_bytes).decode("ascii")
pair["image"] = image_data
payload = {"imageLabelPairs": base_image_label_pairs}
resp_index_build = requests.post(f"{API_BASE_URL}/face-recognition-index-build", json=payload)
if resp_index_build.status_code != 200:
print(f"Request to face-recognition-index-build failed with status code {resp_index_build}.")
pprint.pp(resp_index_build.json())
sys.exit(1)
result_index_build = resp_index_build.json()["result"]
print(f"Number of images indexed: {result_index_build['imageCount']}")
for pair in image_label_pairs_to_add:
with open(pair["image"], "rb") as file:
image_bytes = file.read()
image_data = base64.b64encode(image_bytes).decode("ascii")
pair["image"] = image_data
payload = {"imageLabelPairs": image_label_pairs_to_add, "indexKey": result_index_build["indexKey"]}
resp_index_add = requests.post(f"{API_BASE_URL}/face-recognition-index-add", json=payload)
if resp_index_add.status_code != 200:
print(f"Request to face-recognition-index-add failed with status code {resp_index_add}.")
pprint.pp(resp_index_add.json())
sys.exit(1)
result_index_add = resp_index_add.json()["result"]
print(f"Number of images indexed: {result_index_add['imageCount']}")
payload = {"ids": ids_to_remove, "indexKey": result_index_build["indexKey"]}
resp_index_remove = requests.post(f"{API_BASE_URL}/face-recognition-index-remove", json=payload)
if resp_index_remove.status_code != 200:
print(f"Request to face-recognition-index-remove failed with status code {resp_index_remove}.")
pprint.pp(resp_index_remove.json())
sys.exit(1)
result_index_remove = resp_index_remove.json()["result"]
print(f"Number of images indexed: {result_index_remove['imageCount']}")
with open(infer_image_path, "rb") as file:
image_bytes = file.read()
image_data = base64.b64encode(image_bytes).decode("ascii")
payload = {"image": image_data, "indexKey": result_index_build["indexKey"]}
resp_infer = requests.post(f"{API_BASE_URL}/face-recognition-infer", json=payload)
if resp_infer.status_code != 200:
print(f"Request to face-recogntion-infer failed with status code {resp_infer}.")
pprint.pp(resp_infer.json())
sys.exit(1)
result_infer = resp_infer.json()["result"]
with open(output_image_path, "wb") as file:
file.write(base64.b64decode(result_infer["image"]))
print(f"Output image saved at {output_image_path}")
print("\nDetected faces:")
pprint.pp(result_infer["faces"])
📱 Edge Deployment: Edge deployment is a method of placing computing and data processing capabilities on the user's device itself, allowing the device to process data directly without relying on remote servers. PaddleX supports deploying models on edge devices such as Android. For detailed edge deployment procedures, please refer to the PaddleX Edge Deployment Guide. You can choose the appropriate method to deploy the model pipeline according to your needs, and then proceed with subsequent AI application integration.
4. Secondary Development¶
If the default model weights provided by the face recognition pipeline do not meet your accuracy or speed requirements in your scenario, you can try further fine-tuning the existing model using your own specific domain or application data to improve the recognition performance of the pipeline in your scenario.
4.1 Model Fine-Tuning¶
Since the face recognition pipeline includes two modules (face detection and face feature), the unsatisfactory performance of the model pipeline may come from either module.
You can analyze the images with poor recognition performance. If you find that many faces are not detected during the analysis, it may indicate a deficiency in the face detection model. You need to refer to the Face Detection Module Development Tutorial and the Secondary Development section to fine-tune the face detection model using your private dataset. If there are matching errors in the detected faces, it indicates that the face feature module needs further improvement. You need to refer to the Face Feature Module Development Tutorial and the Secondary Development section to fine-tune the face feature module.
4.2 Model Application¶
After completing the fine-tuning training with your private dataset, you will obtain the local model weight file.
If you need to use the fine-tuned model weights, you only need to modify the pipeline configuration file by replacing the local path of the fine-tuned model weights in the corresponding position of the pipeline configuration file:
...
SubModules:
Detection:
module_name: face_detection
model_name: PP-YOLOE_plus-S_face
model_dir: null # Can be modified to the local path of the fine-tuned face detection model
batch_size: 1
Recognition:
module_name: face_feature
model_name: ResNet50_face
model_dir: null # Can be modified to the local path of the fine-tuned face feature model
batch_size: 1
Subsequently, refer to the command-line or Python script methods in 2.2 Local Experience to load the modified pipeline configuration file.
5. Multi-Hardware Support¶
PaddleX supports a variety of mainstream hardware devices, including NVIDIA GPU, Kunlunxin XPU, Ascend NPU, and Cambricon MLU. Simply modify the --device
parameter to seamlessly switch between different hardware devices.
For example, when running the face recognition pipeline using Python, to change the runtime device from NVIDIA GPU to Ascend NPU, just modify the device
in the script to npu
:
from paddlex import create_pipeline
pipeline = create_pipeline(
pipeline="face_recognition",
device="npu:0" # gpu:0 --> npu:0
)
If you want to use the face recognition pipeline on more types of hardware, please refer to PaddleX Multi-Hardware Usage Guide.