resizeLayer

justadudewhohacks · justadudewhohacks · commit cb52d6202688 · 2018-06-04T08:11:56.000+02:00
diff --git a/src/faceDetectionNet/index.ts b/src/faceDetectionNet/index.ts
@@ -0,0 +1,26 @@
+import * as tf from '@tensorflow/tfjs-core';
+
+import { resizeLayer } from './resizeLayer';
+
+export function faceDetectionNet() {
+
+  async function forward(input: ImageData|ImageData[]) {
+
+    const imgTensors = (input instanceof ImageData ? [input] : input)
+      .map(data => tf.fromPixels(data))
+      .map(data => tf.expandDims(data, 0)) as tf.Tensor4D[]
+
+    const imgTensor = tf.cast(tf.concat(imgTensors, 0), 'float32')
+
+    const resized = resizeLayer(imgTensor)
+
+
+
+
+    return resized
+  }
+
+  return {
+    forward
+  }
+}
diff --git a/src/faceDetectionNet/preprocessor/index.ts b/src/faceDetectionNet/preprocessor/index.ts
diff --git a/src/faceDetectionNet/preprocessor/whileLayer.ts b/src/faceDetectionNet/preprocessor/whileLayer.ts
diff --git a/src/faceDetectionNet/resizeLayer.ts b/src/faceDetectionNet/resizeLayer.ts
@@ -0,0 +1,11 @@
+import * as tf from '@tensorflow/tfjs-core';
+
+// TODO: hardcoded params
+const resizedImageSize = [512, 512] as [number, number]
+const weight = tf.scalar(0.007843137718737125)
+const bias = tf.scalar(1)
+
+export function resizeLayer(imgTensor: tf.Tensor4D) {
+  const resizedImgs = tf.image.resizeBilinear(imgTensor, resizedImageSize, false)
+  return tf.sub(tf.mul(resizedImgs, weight), bias)
+}
diff --git a/src/index.ts b/src/index.ts
@@ -1,9 +1,11 @@
 import { euclideanDistance } from './euclideanDistance';
+import { faceDetectionNet } from './faceDetectionNet';
 import { faceRecognitionNet } from './faceRecognitionNet';
 import { normalize } from './normalize';
 
 export {
   euclideanDistance,
+  faceDetectionNet,
   faceRecognitionNet,
   normalize
 }
diff --git a/src/tfcpatches/TensorArray.ts b/src/tfcpatches/TensorArray.ts
@@ -1,48 +1,56 @@
 import * as tf from '@tensorflow/tfjs-core';
 
 export class TensorArray {
-  private _tensors: tf.Tensor[] | undefined
+  private _tensors: tf.Tensor[]
 
   constructor(
-    private _size: number,
-    private _dtype: tf.DataType = null,
-    private _elementShape: number[] = null,
+    size: number,
+    private _dtype: tf.DataType | null = null,
+    private _elementShape: number[] | null = null,
     private _dynamicSize: boolean = false,
     private _clearAfterRead: boolean = true,
     private _identicalElementShapes: boolean = false,
-    private _tensorArrayName: string = null
+    private _tensorArrayName: string = ''
   ) {
-    if (_size) {
-      this._tensors = Array(_size).fill(0).map(_ => tf.scalar(0))
-    }
+    this._tensors = size
+      ? Array(size).fill(0).map(_ => tf.scalar(0))
+      : []
   }
 
   public scatter(indices: tf.Tensor1D, value: tf.Tensor, unusedFlow: tf.Scalar): tf.Scalar {
+    this.expectValidSize('scatter', indices)
     if (indices.shape.length !== 1) {
       throw new Error(`scatter - expected rank of indices (${indices.shape.length}) to be 1`)
     }
-    if (indices.shape[0] > this._size) {
-      throw new Error(`scatter - expected indices.shape[0] (${indices.shape[0]}) to be >= this._size (${this.size})`)
-    }
     if (indices.shape[0] !== value.shape[0]) {
       throw new Error(`scatter - expected indices.shape[0] (${indices.shape[0]}) to equal value.shape[0] (${value.shape[0]})`)
     }
 
     const unstacked = tf.unstack(value, 0)
     Array.from(indices.dataSync()).forEach((idx, i) => {
-      this._tensors[idx] = unstacked[i]
+      (this._tensors as tf.Tensor[])[idx] = unstacked[i]
     })
 
     const unusedFlowOut = tf.scalar(0)
     return unusedFlowOut
   }
 
   public gather(indices: tf.Tensor1D, unusedFlow: tf.Scalar, dtype?: tf.DataType, elementShape?: number[]) : tf.Tensor {
+    this.expectValidSize('gather', indices)
     const tensors = Array.from(indices.dataSync()).map(idx => this._tensors[idx])
     return tf.concat(tensors)
   }
 
-  public size(unusedFlow: tf.Scalar) {
-    return this._size
+  public size(unusedFlow?: tf.Scalar) {
+    return this._tensors.length
+  }
+
+  private expectValidSize(methodName: string, indices: tf.Tensor1D) {
+    if (!this._tensors) {
+      throw new Error('scatter - TensorArray is not initialized')
+    }
+    if (indices.shape[0] > this._tensors.length) {
+      throw new Error(`${methodName} - expected indices.shape[0] (${indices.shape[0]}) to be >= this.size() (${this.size()})`)
+    }
   }
 }
