முகத்தைக் கண்டறிதல் என்பது பெரும்பாலான கணினி பார்வைத் தொடர்களின் (computer vision pipelines) நுழைவு வாயிலாக உள்ளது. ஒவ்வொரு வீடியோ அழைப்பு, புகைப்படத் தொகுப்பு மற்றும் பாதுகாப்பு கேமராத் தொடர்களும் மற்ற எதையும் செய்வதற்கு முன்பாக மனித முகங்களைக் கண்டறிவதையே நம்பியுள்ளன. இருப்பினும், மாதிரியைத் (model) தேர்ந்தெடுக்கும்போது வழக்கமாக ஒரு சவாலானத் தேர்வைச் சந்திக்க வேண்டியுள்ளது. கனமான நெட்வொர்க்குகள் துல்லியத்தை வழங்குகின்றன, ஆனால் அவற்றுக்கு விலையுயர்ந்த GPUs மற்றும் குளிர்விக்கும் வசதிகள் தேவைப்படுகின்றன. சிறிய மாதிரிகள் சாதாரண வன்பொருள்களில் இயங்குகின்றன, ஆனால் சிறிய முகங்கள் அல்லது அதிகத் தெளிவுத்திறன் கொண்ட காட்சிகளில் பெரும்பாலும் தடுமாறுகின்றன. OpenCV Zoo-வில் உள்ள YuNet மாதிரி இந்தத் தடையை உடைக்கிறது. இது நிஜத் திட்டங்களில் இடம்பெறத் தகுதியானதுதானா அல்லது வெறும் காகித அளவில் மட்டும் சிறப்பாகத் தெரிகிறதா என்பதைப் பார்க்க, பல்வேறு அளவுகளில் (scales) நான் இதைச் சோதித்துப் பார்த்தேன்.

YuNet ஏன் ஒரு நெருக்கமான ஆய்வுக்குத் தகுதியானது

YuNet என்பது வெறும் ஆராய்ச்சித் தேவைக்காக உருவாக்கப்பட்ட ஒன்றல்ல. இது OpenCV DNN மாட்யூலுக்காக மேம்படுத்தப்பட்ட முன்-பயிற்சி பெற்ற மாதிரிகளின் தொகுப்பான OpenCV Zoo-வில் உள்ளது. நான் சோதித்த குறிப்பிட்ட மாறுபாடு INT8 quantization முறையைப் பயன்படுத்துகிறது, அதாவது இதன் எடைகள் (weights) மற்றும் ஆக்டிவேஷன்கள் (activations) வழக்கமான 32-bit floating-point எண்களுக்குப் பதிலாக 8-bit முழு எண்களாகச் சுருக்கப்படுகின்றன. இது ஒரு சிறிய தொழில்நுட்பக் குறிப்பு மட்டுமல்ல. INT8 மெமரி பேண்ட்வித் (memory bandwidth) தேவையை வெகுவாகக் குறைக்கிறது, கேச் அழுத்தத்தைக் (cache pressure) குறைக்கிறது மற்றும் நவீன CPU-கள் எந்த சிரமமுமின்றி இன்ஃபரன்ஸ் (inference) செய்ய அனுமதிக்கிறது. லேப்டாப், எட்ஜ் சாதனம் (edge device) அல்லது பிரத்யேக கிராபிக்ஸ் கார்டு இல்லாத சர்வரைப் பயன்படுத்துபவர்களுக்கு, இந்தத் திறன் ஒரு சீரான செயல்பாட்டிற்கும், தடையற்ற வீடியோவாக இல்லாவிட்டாலும் ஒரு ஸ்லைடுஷோ போலத் தோன்றுவதற்கும் இடையிலான வித்தியாசமாகும்.

இதன் கட்டமைப்பு (architecture) வடிவமைப்பிலேயே மிகவும் லேசானது. இது மிகப்பெரிய பேக்‌போன்களின் (backbones) சுமையைத் தவிர்த்து, முகங்களைக் கண்டறிவதில் மட்டும் கவனம் செலுத்துகிறது. CPU மற்றும் பேட்டரி பயன்பாட்டை ட்ராக்கிங் (tracking), அங்கீகாரம் (recognition) அல்லது வீடியோ என்கோடிங் (video encoding) போன்ற பிற பணிகளுடன் பகிர்ந்து கொள்ள வேண்டிய பெரிய பயன்பாடுகளில், இந்தத் துல்லியமான அணுகுமுறை பெரும் பலன் அளிக்கிறது.

அமைப்பமைப்பு (The Setup)

அனைத்துச் சோதனைகளும் Apple M4 Max சிப் கொண்ட Mac Studio-வில் நடத்தப்பட்டன. OpenCV Zoo களஞ்சியத்திலிருந்து எடுக்கப்பட்ட YuNet INT8 quantized ONNX கட்டமைப்பையே நான் பயன்படுத்தினேன். முதலில் 1280x720 படத்தின் இன்ஃபரன்ஸ் வேகத்தை அளவிட்டேன், பின்னர் அளவு (scale) முடிவுகளை எவ்வாறு பாதிக்கிறது என்பதைப் புரிந்துகொள்ள நான்கு வெவ்வேறு உள்ளீட்டுத் தெளிவுத்திறன்களில் (input resolutions) முகங்களைக் கண்டறியும் எண்ணிக்கையை ஒப்பிட்டுப் பார்த்தேன்.

உங்கள் கணினியில் இந்த எண்களைச் சரிபார்க்க விரும்பினால், இந்தச் செயல்முறையை முழுமையாக மீண்டும் செய்ய முடியும். இந்தச் சுருக்கமான களஞ்சியத்தைப் (sparse repository) பெறவும் பெஞ்ச்மார்க்கை (benchmark) இயக்கவும் பின்வரும் கட்டளைகளைப் பயன்படுத்தவும்:

git clone --depth 1 --filter=blob:none --sparse https://github.com/kiarina/labs.git
cd labs
git sparse-checkout set .gitignore .mise/tasks Makefile mise.toml 2026/07/08/yunet-face-detection
mise -C 2026/07/08/yunet-face-detection run

இந்தச் சுருக்கமான முறை (sparse checkout) பதிவிறக்க அளவைக் குறைக்கிறது, மேலும் mise டாஸ்க் ரன்னர் (task runner) பின்னணியில் தேவையானவற்றைத் தானாகவே கவனித்துக் கொள்கிறது. நீங்கள் Python சூழல்கள் (environments) அல்லது மேனுவல் பேக்கேஜ் இன்ஸ்டாலேஷன்களுடன் போராட வேண்டிய அவசியமில்லை.

சீரான வேகத்தன்மை

1280x720 படத்தில், INT8 YuNet மாதிரி ஒரு இன்ஃபரன்ஸிற்கு சராசரியாக 9.21 மில்லி விநாடிகளை எடுத்துக்கொண்டது. மிக வேகமான முறை 8.03 ms ஆகவும், மிக மெதுவான முறை 10.47 ms ஆகவும் இருந்தது. இது வியக்கத்தக்க வகையில் மிகக் குறுகிய இடைவெளியாகும். சிறந்த மற்றும் மோசமான நேரங்களுக்கு இடையே இரண்டு மற்றும் அரை மில்லி விநாடிகளுக்கும் குறைவாகவே வித்தியாசம் உள்ளது.

நடைமுறையில், இந்தத் தொடர்ச்சியான தன்மை (consistency) வெறும் பெருமைக்காக அல்ல, அது மிகவும் முக்கியமானது. நிகழ்நேரப் பயன்பாடுகளுக்கு (real-time applications) குறைந்த சராசரி லேட்டன்சி (latency) மட்டும் போதாது; கணிக்கக்கூடிய லேட்டன்சி (predictable latency) தேவைப்படுகிறது. சில நேரங்களில் 50 ms எடுக்கும் ஒரு மாதிரி, வெப்கேம் காட்சியில் தடையை ஏற்படுத்தும். YuNet சீராக இயங்குகிறது. அடுத்த பிரேம் வருவதற்கு முன்பே தற்போதைய பிரேமை முடிக்க இது உதவும், இது உங்கள் முழுத் தொடரையும் (pipeline) திட்டமிடுவதை எளிதாக்குகிறது.

அளவீட்டு மாறுபாடு உண்மையை வெளிப்படுத்துகிறது

ஒரு காட்சித் தொடரில் பாதி முகங்களைக் கூட மாதிரி தவறவிட்டால், வெறும் வேகம் எதற்கும் உதவாது. இதைச் சோதிக்க, நான் நான்கு வெவ்வேறு தெளிவுத்திறன்களில் YuNet மூலம் ஒரே மூலப் படங்களை உள்ளீடாகக் கொடுத்தேன். அதன் முடிவுகள் ஒரு தெளிவான கதையைச் சொல்கின்றன:

  • 320 x 180: 6 முகங்கள் கண்டறியப்பட்டன
  • 640 x 360: 26 முகங்கள் கண்டறியப்பட்டன
  • 1280 x 720: 38 முகங்கள் கண்டறியப்பட்டன
  • 2560 x 1440: 52 முகங்கள் கண்டறியப்பட்டன

இந்த உயர்வு வியக்கத்தக்கது. 320 x 180 இல், மிகப்பெரிய மற்றும் மிக அருகில் உள்ள முகங்கள் மட்டுமே கண்டறியப்படுகின்றன. 640 x 360 ஆக உயர்த்தும்போது, எண்ணிக்கை நான்கு மடங்கு அதிகரிக்கிறது. முழுமையான 1440p இல், மிகக் குறைந்த தெளிவுத்திறனில் கண்டறியப்பட்ட முகங்களை விட எட்டு மடங்குக்கும் அதிகமான முகங்களை YuNet கண்டறிகிறது.

இது ஏன் நடக்கிறது என்றால், டவுன்சாம்பிளிங் (downsampling) நுணுக்கங்களை நாம் நினைப்பதை விட வேகமாக அழித்துவிடுகிறது. 1440p பிரேமில் ஒரு சிறிய பகுதியை மட்டும் ஆக்கிரமித்துள்ள முகம், 360p இல் வெறும் ஐந்து பைதல் (pixels) அளவுள்ள ஒரு புள்ளியாகச் சுருங்கிவிடும். முகத்தின் அம்சங்கள் மாதிரியின் ரீசெப்டிவ் ஃபீல்டைத் (receptive field) தாண்டிச் சுருங்கிவிட்டால், அவை கண்ணுக்குத் தெரியாத இரைச்சலாக (noise) மாறிவிடும். கண்கள் புருவங்களோடு இணைந்துவிடும். மூக்கு மறைந்துவிடும். YuNet-ஆல் எதையும் பிடித்துக் கொள்ள முடியாது.

இதன் நடைமுறைப் பயன் முக்கியமானது. உங்கள் கேமரா ஒரு வகுப்பறை, ஒரு கூட்ட அரங்கு அல்லது ஒரு தெரு முனையின் அகலமான காட்சியைப் படம்பிடித்தால், மாதிரிக்கு போதுமான பிக்சல்களைத் தராவிட்டால், தொலைவில் உள்ள முகங்கள் தெரியாது. இங்கே தெளிவுத்திறன் (resolution) என்பது வெறும் படத்தின் தரத்தைப் பற்றியது மட்டுமல்ல; அது ரீகால் (recall) திறனை நேரடியாகப் பாதிக்கும் ஒரு காரணியாகும்.

உங்களுக்குத் தேவையான உண்மையான ரீசைஸ் (Resize) உத்தி

YuNet is fast enough that you do not need to hammer your input down to 320 x 240 out of habit. On the M4 Max, even 2560 x 1440 runs without a dedicated GPU. That changes how you should architect a pipeline.

Instead of forcing every frame through a tiny fixed size, choose your input resolution based on what you are trying to find. If you only care about the person directly in front of the camera, 720p or even 640p is plenty. If you need to catalog every attendee in a large hall, feed the model a higher-resolution crop or the full native frame. Because YuNet is lightweight, you have headroom to make that choice. You are not locked into a single preset to avoid a 200 ms lag.

One caveat does remain. The model still depends on face size relative to the input tensor. There is no magic scale invariance here. Small faces stay invisible unless they occupy enough pixels. The fix is mechanical: resize your source image upward before inference when hunting for distant subjects, then map the resulting bounding boxes back to original coordinates. YuNet gives you the speed budget to afford that step.

Where This Fits in Your Stack

YuNet is not a solution for every conceivable face task. Heavy occlusion, extreme profile angles, or 3D mesh extraction are outside its scope. But for the bread-and-butter work of locating faces in photos and video streams, it occupies a sweet spot. Real-time webcam apps, automated photo culling tools, and modest embedded systems all benefit from a detector that runs fast on standard CPUs.

The INT8 ONNX format also makes deployment painless. You do not need to install PyTorch or TensorFlow on the target device. OpenCV's DNN module loads the model directly, which keeps your binary small and your dependency tree shallow.

The Bottom Line

YuNet proves that face detection does not require industrial hardware or bloated frameworks. The numbers speak plainly: under ten milliseconds for a 720p frame, and a direct, predictable boost in detection count as resolution rises. You get to choose whether you want maximum speed at moderate resolution or broader coverage at higher scale, and the model will not punish you for that choice.

If you are building anything that touches real-world imagery, run the reproduction steps above on your own hardware. Test it against your footage. Then tune your resize logic to match the faces you actually need to find. Speed is useful only when you can aim it. YuNet gives you both the velocity and the control.