* **[Face Detection - SSD Mobilenet v1](#about-face-detection-ssd)**

* **[Face Detection & 5 Point Face Landmarks - MTCNN](#about-face-detection-mtcnn)**

* **[68 Point Face Landmark Detection](#about-face-landmark-detection)**

* **[Face Detection - SSD Mobilenet v1](#usage-face-detection-ssd)**

* **[Face Detection & 5 Point Face Landmarks - MTCNN](#usage-face-detection-mtcnn)**

* **[68 Point Face Landmark Detection](#usage-face-landmark-detection)**

**SSD Mobilenet v1**

**MTCNN**


<a name="about-face-detection-ssd"></a>

For face detection, this project implements a SSD (Single Shot Multibox Detector) based on MobileNetV1. The neural net will compute the locations of each face in an image and will return the bounding boxes together with it's probability for each face. This face detector is aiming towards obtaining high accuracy in detecting face bounding boxes instead of low inference time.

<a name="about-face-detection-mtcnn"></a>

MTCNN (Multi-task Cascaded Convolutional Neural Networks) represents an alternative to SSD Mobilenet v1, which offers much more room for configuration and is able to achieve much lower processing times. MTCNN is a 3 stage cascaded CNN, which simultanously returns 5 face landmark points along with the bounding boxes and scores for each face. By limiting the minimum size of faces expected in an image, MTCNN allows you to process frames from your webcam in realtime. Additionally with 2MB, the size of the weights file is only a third of the size of the quantized SSD Mobilenet v1 model (~6MB).

MTCNN has been presented in the paper [Joint Face Detection and Alignment using Multi-task Cascaded Convolutional Networks](https://kpzhang93.github.io/MTCNN_face_detection_alignment/paper/spl.pdf) by Zhang et al. and the model weights are provided in the official [repo](https://github.com/kpzhang93/MTCNN_face_detection_alignment) of the MTCNN implementation.

<a name="usage-face-detection-ssd"></a>

<a name="usage-face-detection-mtcnn"></a>

Detect faces and get the bounding boxes and scores:

``` javascript

const forwardParams = {

// number of scaled versions of the input image passed through the CNN

// of the first stage, lower numbers will result in lower inference time,

// but will also be less accurate

maxNumScales: 10,

// scale factor used to calculate the scale steps of the image

// pyramid used in stage 1

scaleFactor: 0.709,

// the score threshold values used to filter the bounding

// boxes of stage 1, 2 and 3

scoreThresholds: [0.6, 0.7, 0.7],

// mininum face size to expect, the higher the faster processing will be,

// but smaller faces won't be detected

minFaceSize: 20

}

const results = await faceapi.mtcnn(document.getElementById('myImg'), forwardParams)

Alternatively you can also specify the scale steps manually:

``` javascript

const forwardParams = {

scaleSteps: [0.4, 0.2, 0.1, 0.05]

}

const results = await faceapi.mtcnn(document.getElementById('myImg'), forwardParams)

Finally you can draw the returned bounding boxes and 5 Point Face Landmarks into a canvas:

``` javascript

const minConfidence = 0.9

if (results) {

results.forEach(({ faceDetection, faceLandmarks }) => {

// ignore results with low confidence score

if (faceDetection.score < minConfidence) {

return

}

faceapi.drawDetection('overlay', faceDetection)

faceapi.drawLandmarks('overlay', faceLandmarks)

})

}

console.log(fullFaceDescription0.descriptor) // face descriptor

import { Rect } from './Rect';

import { Dimensions } from './types';

export declare class FaceDetection {

private _score;

private _box;

private _imageWidth;

private _imageHeight;

constructor(score: number, relativeBox: Rect, imageDims: Dimensions);

readonly score: number;

readonly box: Rect;

readonly imageWidth: number;

readonly imageHeight: number;

readonly relativeBox: Rect;

getScore(): number;

getBox(): Rect;

getImageWidth(): number;

getImageHeight(): number;

getRelativeBox(): Rect;

forSize(width: number, height: number): FaceDetection;

import { Point } from './Point';

import { Dimensions } from './types';

export declare class FaceLandmarks {

protected _imageWidth: number;

protected _imageHeight: number;

protected _shift: Point;

protected _faceLandmarks: Point[];

constructor(relativeFaceLandmarkPositions: Point[], imageDims: Dimensions, shift?: Point);

getShift(): Point;

getImageWidth(): number;

getImageHeight(): number;

getPositions(): Point[];

getRelativePositions(): Point[];

import { FaceDetection } from './FaceDetection';

import { FaceLandmarks68 } from './faceLandmarkNet/FaceLandmarks68';

constructor(_detection: FaceDetection, _landmarks: FaceLandmarks68, _descriptor: Float32Array);

readonly landmarks: FaceLandmarks68;

private _canvases;

constructor(inputs: tf.Tensor4D | Array<TResolvedNetInput>, isBatchInput?: boolean, keepCanvases?: boolean);

readonly canvases: HTMLCanvasElement[];