ブルゾンちえみ判別器をブラウザ上に実装する

cascade_path = '../opencvjs/test/data/haarcascade_frontalface_default.xml'
classifier = cv2.CascadeClassifier(cascade_path)

for f in glob.glob('data/raw_images/*'):
    img = cv2.imread(f)
    faces = classifier.detectMultiScale(img, scaleFactor=1.1, minNeighbors=1, minSize=(1, 1))
    if len(faces) == 1:
        rect = faces[0]
        roi = img[rect[1]:rect[1] + rect[3], rect[0]:rect[0] + rect[2]]
        cv2.imwrite(f.replace('raw_images', 'faces'), roi)

def inference(images_placeholder, keep_prob):
    def weight_variable(shape):
      initial = tf.truncated_normal(shape, stddev=0.1)
      return tf.Variable(initial, name='weights')

    def bias_variable(shape):
      initial = tf.constant(0.1, shape=shape)
      return tf.Variable(initial, name='biases')

    # 畳み込み層の作成
    def conv2d(x, W):
      return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

    # プーリング層の作成
    def max_pool_2x2(x):
      return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

    # 入力を28x28x3に変形
    x_image = tf.reshape(images_placeholder, [-1, 28, 28, 3])

    # 畳み込み層1の作成
    with tf.name_scope('conv1') as scope:
        W_conv1 = weight_variable([5, 5, 3, 32])
        b_conv1 = bias_variable([32])
        h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)

    # プーリング層1の作成
    with tf.name_scope('pool1') as scope:
        h_pool1 = max_pool_2x2(h_conv1)

    # 畳み込み層2の作成
    with tf.name_scope('conv2') as scope:
        W_conv2 = weight_variable([5, 5, 32, 64])
        b_conv2 = bias_variable([64])
        h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)

    # プーリング層2の作成
    with tf.name_scope('pool2') as scope:
        h_pool2 = max_pool_2x2(h_conv2)

    # 全結合層1の作成
    with tf.name_scope('fc1') as scope:
        W_fc1 = weight_variable([7*7*64, 1024])
        b_fc1 = bias_variable([1024])
        h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
        h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
        # dropoutの設定
        h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

    # 全結合層2の作成
    with tf.name_scope('fc2') as scope:
        W_fc2 = weight_variable([1024, NUM_CLASSES])
        b_fc2 = bias_variable([NUM_CLASSES])

    # ソフトマックス関数による正規化
    with tf.name_scope('softmax') as scope:
        y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

    # 各ラベルの確率のようなものを返す
    return y_conv

function createInfer(math: NDArrayMath,  vars: { [varName: string]: NDArray }) {
  // セッションのチェックポイント時点における変数を復元
  const W_conv1 = vars["conv1/weights"] as Array4D, b_conv1 = vars["conv1/biases"] as Array1D;
  const W_conv2 = vars["conv2/weights"] as Array4D, b_conv2 = vars["conv2/biases"] as Array1D;
  const W_fc1 = vars["fc1/weights"] as Array2D, b_fc1 = vars["fc1/biases"] as Array1D;
  const W_fc2 = vars["fc2/weights"] as Array2D, b_fc2 = vars["fc2/biases"] as Array1D;

  return (x: Array4D) => {
    const conv2d = (input: Array4D, weight: Array4D) => math.conv2d(input, weight, null, [1, 1], "same");
    const max_pool_2x2 = (x: NDArray) => math.maxPool(x, [2, 2], [2, 2], "same");

    // 畳み込み層1の作成
    const h_conv1 = math.relu(math.add(conv2d(x, W_conv1), b_conv1));

    // プーリング層1の作成
    const h_pool1 = max_pool_2x2(h_conv1) as Array4D;

    // 畳み込み層2の作成
    const h_conv2 = math.relu(math.add(conv2d(h_pool1, W_conv2), b_conv2));

    // プーリング層2の作成
    const h_pool2 = max_pool_2x2(h_conv2) as Array4D;

    // 全結合層1の作成
    const h_pool2Mat = h_pool2.as2D(1, 7 * 7 * 64);
    const h_fc1 = math.relu(math.add(math.matMul(h_pool2Mat, W_fc1), b_fc1)) as Array2D;

    // 全結合層2, softmax計算
    const y_conv = math.softmax(math.add(math.matMul(h_fc1, W_fc2), b_fc2));

    return y_conv as Array2D;
  };
}

function detectFace(inputImage) {
    const classifier = new cv.CascadeClassifier();
    classifier.load('../../test/data/haarcascade_frontalface_default.xml');
    const imgRaw = cv.matFromArray(inputImage, cv.CV_8UC4);
    const imgColor = new cv.Mat();
    cv.cvtColor(imgRaw, imgColor, cv.ColorConversionCodes.COLOR_RGBA2BGR.value, 0);
    const faces = new cv.RectVector();
    classifier.detectMultiScale(imgColor, faces, 1.1, 3, 0, [0, 0], [0, 0]);

    let x;
    if (!faces.size()) {
      x = imgColor;
    } else {
      const rect = faces.get(0);
      x = imgColor.getROI_Rect(rect);
    }

    const resized = new cv.Mat();
    cv.resize(x, resized, [28, 28], 0, 0, 0);
    const faceData = new Uint8Array(resized.data());
    [imgRaw, imgColor, faces, classifier, resized].forEach(p => p.delete());
    return faceData;
}

function toFloatList(data) {
  const out = new Float32Array(data.length);
  for (let i = 0; i < data.length; ++i) {
    out[i] = data[i] / 255.0;
  }
  return Array1D.new(out).as4D(1, 28, 28, 3);
}

async function execInfer(faceData) {
  const logits = infer(toFloatList(faceData));
  const conv = await logits.data();  // ここに誰の確率かが入ってるので、値がもっとも大きいインデックスを探索すればOK
}