copy contents of tfjs-image-recognition-base to face-api.js + remove dependency

Author: justadudewhohacks

karma.conf.js

@@ -2,6 +2,7 @@ const dataFiles = [
   'test/images/*.jpg',
   'test/images/*.png',
   'test/data/*.json',
+  'test/data/*.weights',
   'test/media/*.mp4',
   'weights/**/*',
   'weights_uncompressed/**/*',

package-lock.json

@@ -40,7 +40,6 @@
   "license": "MIT",
   "dependencies": {
     "@tensorflow/tfjs-core": "1.2.9",
-    "tfjs-image-recognition-base": "^0.6.2",
     "tslib": "^1.10.0"
   },
   "devDependencies": {

package.json

@@ -0,0 +1,159 @@
+import * as tf from '@tensorflow/tfjs-core';
+
+import { ParamMapping } from './common';
+import { getModelUris } from './common/getModelUris';
+import { loadWeightMap } from './dom';
+import { env } from './env';
+
+export abstract class NeuralNetwork<TNetParams> {
+
+  protected _params: TNetParams | undefined = undefined
+  protected _paramMappings: ParamMapping[] = []
+
+  constructor(protected _name: string) {}
+
+  public get params(): TNetParams | undefined { return this._params }
+  public get paramMappings(): ParamMapping[] { return this._paramMappings }
+  public get isLoaded(): boolean { return !!this.params }
+
+  public getParamFromPath(paramPath: string): tf.Tensor {
+    const { obj, objProp } = this.traversePropertyPath(paramPath)
+    return obj[objProp]
+  }
+
+  public reassignParamFromPath(paramPath: string, tensor: tf.Tensor) {
+    const { obj, objProp } = this.traversePropertyPath(paramPath)
+    obj[objProp].dispose()
+    obj[objProp] = tensor
+  }
+
+  public getParamList() {
+    return this._paramMappings.map(({ paramPath }) => ({
+      path: paramPath,
+      tensor: this.getParamFromPath(paramPath)
+    }))
+  }
+
+  public getTrainableParams() {
+    return this.getParamList().filter(param => param.tensor instanceof tf.Variable)
+  }
+
+  public getFrozenParams() {
+    return this.getParamList().filter(param => !(param.tensor instanceof tf.Variable))
+  }
+
+  public variable() {
+    this.getFrozenParams().forEach(({ path, tensor }) => {
+      this.reassignParamFromPath(path, tensor.variable())
+    })
+  }
+
+  public freeze() {
+    this.getTrainableParams().forEach(({ path, tensor: variable }) => {
+      const tensor = tf.tensor(variable.dataSync())
+      variable.dispose()
+      this.reassignParamFromPath(path, tensor)
+    })
+  }
+
+  public dispose(throwOnRedispose: boolean = true) {
+    this.getParamList().forEach(param => {
+      if (throwOnRedispose && param.tensor.isDisposed) {
+        throw new Error(`param tensor has already been disposed for path ${param.path}`)
+      }
+      param.tensor.dispose()
+    })
+    this._params = undefined
+  }
+
+  public serializeParams(): Float32Array {
+    return new Float32Array(
+      this.getParamList()
+        .map(({ tensor }) => Array.from(tensor.dataSync()) as number[])
+        .reduce((flat, arr) => flat.concat(arr))
+    )
+  }
+
+  public async load(weightsOrUrl: Float32Array | string | undefined): Promise<void> {
+    if (weightsOrUrl instanceof Float32Array) {
+      this.extractWeights(weightsOrUrl)
+      return
+    }
+
+    await this.loadFromUri(weightsOrUrl)
+  }
+
+  public async loadFromUri(uri: string | undefined) {
+    if (uri && typeof uri !== 'string') {
+      throw new Error(`${this._name}.loadFromUri - expected model uri`)
+    }
+
+    const weightMap = await loadWeightMap(uri, this.getDefaultModelName())
+    this.loadFromWeightMap(weightMap)
+  }
+
+  public async loadFromDisk(filePath: string | undefined) {
+    if (filePath && typeof filePath !== 'string') {
+      throw new Error(`${this._name}.loadFromDisk - expected model file path`)
+    }
+
+    const { readFile } = env.getEnv()
+
+    const { manifestUri, modelBaseUri } = getModelUris(filePath, this.getDefaultModelName())
+
+    const fetchWeightsFromDisk = (filePaths: string[]) => Promise.all(
+      filePaths.map(filePath => readFile(filePath).then(buf => buf.buffer))
+    )
+    const loadWeights = tf.io.weightsLoaderFactory(fetchWeightsFromDisk)
+
+    const manifest = JSON.parse((await readFile(manifestUri)).toString())
+    const weightMap = await loadWeights(manifest, modelBaseUri)
+
+    this.loadFromWeightMap(weightMap)
+  }
+
+  public loadFromWeightMap(weightMap: tf.NamedTensorMap) {
+    const {
+      paramMappings,
+      params
+    } = this.extractParamsFromWeigthMap(weightMap)
+
+    this._paramMappings = paramMappings
+    this._params = params
+  }
+
+  public extractWeights(weights: Float32Array) {
+    const {
+      paramMappings,
+      params
+    } = this.extractParams(weights)
+
+    this._paramMappings = paramMappings
+    this._params = params
+  }
+
+  private traversePropertyPath(paramPath: string) {
+    if (!this.params) {
+      throw new Error(`traversePropertyPath - model has no loaded params`)
+    }
+
+    const result = paramPath.split('/').reduce((res: { nextObj: any, obj?: any, objProp?: string }, objProp) => {
+      if (!res.nextObj.hasOwnProperty(objProp)) {
+        throw new Error(`traversePropertyPath - object does not have property ${objProp}, for path ${paramPath}`)
+      }
+
+      return { obj: res.nextObj, objProp, nextObj: res.nextObj[objProp] }
+    }, { nextObj: this.params })
+
+    const { obj, objProp } = result
+    if (!obj || !objProp || !(obj[objProp] instanceof tf.Tensor)) {
+      throw new Error(`traversePropertyPath - parameter is not a tensor, for path ${paramPath}`)
+    }
+
+    return { obj, objProp }
+  }
+
+  protected abstract getDefaultModelName(): string
+  protected abstract extractParamsFromWeigthMap(weightMap: tf.NamedTensorMap): { params: TNetParams, paramMappings: ParamMapping[] }
+  protected abstract extractParams(weights: Float32Array): { params: TNetParams, paramMappings: ParamMapping[] }
+}

src/NeuralNetwork.ts

@@ -1,12 +1,13 @@
 import * as tf from '@tensorflow/tfjs-core';
-import { NetInput, NeuralNetwork, TNetInput, toNetInput } from 'tfjs-image-recognition-base';
 
 import { fullyConnectedLayer } from '../common/fullyConnectedLayer';
 import { seperateWeightMaps } from '../faceProcessor/util';
 import { TinyXception } from '../xception/TinyXception';
 import { extractParams } from './extractParams';
 import { extractParamsFromWeigthMap } from './extractParamsFromWeigthMap';
 import { AgeAndGenderPrediction, Gender, NetOutput, NetParams } from './types';
+import { NeuralNetwork } from '../NeuralNetwork';
+import { NetInput, TNetInput, toNetInput } from '../dom';
 
 export class AgeGenderNet extends NeuralNetwork<NetParams> {
 

src/ageGenderNet/AgeGenderNet.ts

@@ -1,17 +1,16 @@
-import { TfjsImageRecognitionBase } from 'tfjs-image-recognition-base';
-
+import { extractFCParamsFactory, extractWeightsFactory, ParamMapping } from '../common';
 import { NetParams } from './types';
 
-export function extractParams(weights: Float32Array): { params: NetParams, paramMappings: TfjsImageRecognitionBase.ParamMapping[] } {
+export function extractParams(weights: Float32Array): { params: NetParams, paramMappings: ParamMapping[] } {
 
-  const paramMappings: TfjsImageRecognitionBase.ParamMapping[] = []
+  const paramMappings: ParamMapping[] = []
 
   const {
     extractWeights,
     getRemainingWeights
-  } = TfjsImageRecognitionBase.extractWeightsFactory(weights)
+  } = extractWeightsFactory(weights)
 
-  const extractFCParams = TfjsImageRecognitionBase.extractFCParamsFactory(extractWeights, paramMappings)
+  const extractFCParams = extractFCParamsFactory(extractWeights, paramMappings)
 
   const age = extractFCParams(512, 1, 'fc/age')
   const gender = extractFCParams(512, 2, 'fc/gender')

src/ageGenderNet/extractParams.ts

@@ -1,17 +1,17 @@
 import * as tf from '@tensorflow/tfjs-core';
-import { TfjsImageRecognitionBase } from 'tfjs-image-recognition-base';
 
+import { disposeUnusedWeightTensors, extractWeightEntryFactory, FCParams, ParamMapping } from '../common';
 import { NetParams } from './types';
 
 export function extractParamsFromWeigthMap(
   weightMap: tf.NamedTensorMap
-): { params: NetParams, paramMappings: TfjsImageRecognitionBase.ParamMapping[] } {
+): { params: NetParams, paramMappings: ParamMapping[] } {
 
-  const paramMappings: TfjsImageRecognitionBase.ParamMapping[] = []
+  const paramMappings: ParamMapping[] = []
 
-  const extractWeightEntry = TfjsImageRecognitionBase.extractWeightEntryFactory(weightMap, paramMappings)
+  const extractWeightEntry = extractWeightEntryFactory(weightMap, paramMappings)
 
-  function extractFcParams(prefix: string): TfjsImageRecognitionBase.FCParams {
+  function extractFcParams(prefix: string): FCParams {
     const weights = extractWeightEntry<tf.Tensor2D>(`${prefix}/weights`, 2)
     const bias = extractWeightEntry<tf.Tensor1D>(`${prefix}/bias`, 1)
     return { weights, bias }
@@ -24,7 +24,7 @@ export function extractParamsFromWeigthMap(
     }
   }
 
-  TfjsImageRecognitionBase.disposeUnusedWeightTensors(weightMap, paramMappings)
+  disposeUnusedWeightTensors(weightMap, paramMappings)
 
   return { params, paramMappings }
 }

src/ageGenderNet/extractParamsFromWeigthMap.ts

@@ -1,5 +1,6 @@
 import * as tf from '@tensorflow/tfjs-core';
-import { TfjsImageRecognitionBase } from 'tfjs-image-recognition-base';
+
+import { FCParams } from '../common';
 
 export type AgeAndGenderPrediction = {
   age: number
@@ -16,7 +17,7 @@ export type NetOutput = { age: tf.Tensor1D, gender: tf.Tensor2D }
 
 export type NetParams = {
   fc: {
-    age: TfjsImageRecognitionBase.FCParams
-    gender: TfjsImageRecognitionBase.FCParams
+    age: FCParams
+    gender: FCParams
   }
 }

src/ageGenderNet/types.ts

@@ -0,0 +1,14 @@
+import { Box } from './Box';
+
+export interface IBoundingBox {
+  left: number
+  top: number
+  right: number
+  bottom: number
+}
+
+export class BoundingBox extends Box<BoundingBox> implements IBoundingBox {
+  constructor(left: number, top: number, right: number, bottom: number, allowNegativeDimensions: boolean = false) {
+    super({ left, top, right, bottom }, allowNegativeDimensions)
+  }
+}