性能测试

"""Measure synchronous still-image detection latency (not camera FPS)."""
import argparse
import math
import statistics
import time

import cv2
import inspireface as isf


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("image")
    parser.add_argument("--model", required=True)
    parser.add_argument("--runs", type=int, default=100)
    parser.add_argument("--warmup", type=int, default=20)
    args = parser.parse_args()
    if args.runs < 1 or args.warmup < 0:
        parser.error("runs must be positive and warmup must be non-negative")
    image = cv2.imread(args.image)
    if image is None:
        parser.error("Cannot read the input image")
    isf.launch(resource_path=args.model)
    try:
        with isf.InspireFaceSession(
            isf.HF_ENABLE_NONE, isf.HF_DETECT_MODE_ALWAYS_DETECT,
            max_detect_num=10, detect_pixel_level=320, auto_launch=False,
        ) as session:
            with isf.ImageStream.load_from_cv_image(image) as stream:
                for _ in range(args.warmup):
                    session.face_detection(stream)
                elapsed = []
                counts = set()
                for _ in range(args.runs):
                    start = time.perf_counter_ns()
                    faces = session.face_detection(stream)
                    elapsed.append((time.perf_counter_ns() - start) / 1_000_000)
                    counts.add(len(faces))
        ordered = sorted(elapsed)
        p95 = ordered[math.ceil(0.95 * len(ordered)) - 1]
        print(f"native={isf.version()}, image={image.shape}, face_counts={sorted(counts)}")
        print(f"ALWAYS_DETECT, level=320, max_faces=10, runs={args.runs}")
        print(f"median={statistics.median(elapsed):.3f} ms, p95={p95:.3f} ms")
    finally:
        isf.terminate()


if __name__ == "__main__":
    main()

"""Measure aligned feature extraction and comparison with the Python API."""
import argparse
import math
import statistics
import time

import cv2
import inspireface as isf


def measure(operation, warmup, runs, label, unit):
    for _ in range(warmup):
        operation()
    samples = []
    for _ in range(runs):
        start = time.perf_counter_ns()
        result = operation()
        samples.append(time.perf_counter_ns() - start)
    samples.sort()
    scale = 1_000_000 if unit == "ms" else 1_000
    p95 = samples[math.ceil(0.95 * runs) - 1] / scale
    print(f"{label}: median={statistics.median(samples) / scale:.3f} {unit}, "
          f"p95={p95:.3f} {unit}")
    return result


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("image1")
    parser.add_argument("image2")
    parser.add_argument("--model", required=True)
    parser.add_argument("--runs", type=int, default=100)
    parser.add_argument("--warmup", type=int, default=20)
    args = parser.parse_args()
    if args.runs < 1 or args.warmup < 0:
        parser.error("runs must be positive and warmup must be non-negative")
    image1, image2 = cv2.imread(args.image1), cv2.imread(args.image2)
    if image1 is None or image2 is None:
        parser.error("Cannot read one or both input images")

    isf.launch(resource_path=args.model)
    try:
        with isf.InspireFaceSession(
            isf.HF_ENABLE_FACE_RECOGNITION, isf.HF_DETECT_MODE_ALWAYS_DETECT,
            max_detect_num=10, detect_pixel_level=320, auto_launch=False,
        ) as session:
            with isf.ImageStream.load_from_cv_image(image1) as stream1, \
                    isf.ImageStream.load_from_cv_image(image2) as stream2:
                faces1 = session.face_detection(stream1)
                faces2 = session.face_detection(stream2)
                if len(faces1) != 1 or len(faces2) != 1:
                    raise ValueError(f"Expected one face per image; got {len(faces1)} and {len(faces2)}")
                feature2 = session.face_feature_extract(stream2, faces2[0])
                print(f"native={isf.version()}, model={args.model}")
                print(f"image1={image1.shape}, image2={image2.shape}, "
                      f"warmup={args.warmup}, runs={args.runs}")
                feature1 = measure(
                    lambda: session.face_feature_extract(stream1, faces1[0]),
                    args.warmup, args.runs, "extract image1 (alignment included)", "ms",
                )
                score = measure(
                    lambda: isf.feature_comparison(feature1, feature2),
                    args.warmup, args.runs, "compare two prepared embeddings", "us",
                )
                print(f"feature_length={feature1.size}, cosine_similarity={score:.6f}")
    finally:
        isf.terminate()


if __name__ == "__main__":
    try:
        main()
    except Exception as error:
        raise SystemExit(f"Benchmark failed: {error}") from error