TensorFlow Graphics : Beginner Tutorials : 物体ポーズ推定 / 整列 (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/25/2019

* 本ページは、TensorFlow Graphics の github レポジトリの次のページを翻訳した上で適宜、補足説明したものです：

• https://github.com/tensorflow/graphics/blob/master/tensorflow_graphics/notebooks/6dof_alignment.ipynb

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

TensorFlow Graphics : Beginner Tutorials : 物体ポーズ推定 / 整列

物体のポーズを正確に推定することは多くの業種 (= industries) で基本的です。例えば拡張現実と仮想現実において、これらのオブジェクトと相互作用することによりそれはユーザに幾つかの変数の状態を変更することを可能にします (e.g. ユーザのデスクの上のマグにより制御される容量)。

このノートブックは既知の 3D 物体の回転と移動を推定するために TensorFlow Graphics をどのように使用するかを示します。

この能力は 2 つの異なるデモにより示されます :

1. 機械学習デモ、これは与えられた物体の参照ポーズに関する回転と移動を正確に見積もることができる単純なニューラルネットワークをどのように訓練するかを示します。
2. 数学的最適化デモ、これはこの問題への異なるアプローチを取ります ; 機械学習は使用しません。

 

セットアップ & Imports

このノートブックに含まれるデモを実行するために必要な総てを import しましょう。

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import time

import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

from tensorflow_graphics.geometry.transformation import quaternion
from tensorflow_graphics.math import vector
from tensorflow_graphics.notebooks import threejs_visualization
from tensorflow_graphics.notebooks.resources import tfg_simplified_logo

tf.enable_eager_execution()

# Loads the Tensorflow Graphics simplified logo.
vertices = tfg_simplified_logo.mesh['vertices'].astype(np.float32)
faces = tfg_simplified_logo.mesh['faces']
num_vertices = vertices.shape[0]

 

1. 機械学習

モデル定義

既知のメッシュの総ての頂点の 3D 位置が与えられたとき、参照ポーズに関するこのメッシュの (クォータニオン (4 次元ベクトル) によりパラメータ化された) 回転と移動 (3 次元ベクトル) を予測する能力があるネットワークを望みます。今、タスクのための非常に単純な 3-層完全結合ネットワークと損失を作成しましょう。このモデルは非常に単純で明らかに最善ではないことに注意してください、それはこのノートブックのためには範囲外です。

# モデルを構築する。
model = keras.Sequential()
model.add(layers.Flatten(input_shape=(num_vertices, 3)))
model.add(layers.Dense(64, activation=tf.nn.tanh))
model.add(layers.Dense(64, activation=tf.nn.relu))
model.add(layers.Dense(7))


def pose_estimation_loss(y_true, y_pred):
  """訓練のために使用されるポーズ推定損失。

  This loss measures the average of squared distance between some vertices
  of the mesh in 'rest pose' and the transformed mesh to which the predicted
  inverse pose is applied. Comparing this loss with a regular L2 loss on the
  quaternion and translation values is left as exercise to the interested
  reader.

  Args:
    y_true: The ground-truth value.
    y_pred: The prediction we want to evaluate the loss for.

  Returns:
    A scalar value containing the loss described in the description above.
  """
  # y_true.shape : (batch, 7)
  y_true_q, y_true_t = tf.split(y_true, (4, 3), axis=-1)
  # y_pred.shape : (batch, 7)
  y_pred_q, y_pred_t = tf.split(y_pred, (4, 3), axis=-1)

  # vertices.shape: (num_vertices, 3)
  # corners.shape:(num_vertices, 1, 3)
  corners = tf.expand_dims(vertices, axis=1)

  # transformed_corners.shape: (num_vertices, batch, 3)
  # q and t shapes get pre-pre-padded with 1's following standard broadcast rules.
  transformed_corners = quaternion.rotate(corners, y_pred_q) + y_pred_t

  # recovered_corners.shape: (num_vertices, batch, 3)
  recovered_corners = quaternion.rotate(transformed_corners - y_true_t,
                                        quaternion.inverse(y_true_q))

  # vertex_error.shape: (num_vertices, batch)
  vertex_error = tf.reduce_sum((recovered_corners - corners)**2, axis=-1)

  return tf.reduce_mean(vertex_error)


optimizer = keras.optimizers.Adam()
model.compile(loss=pose_estimation_loss, optimizer=optimizer)

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
flatten (Flatten)            (None, 114)               0         
_________________________________________________________________
dense (Dense)                (None, 64)                7360      
_________________________________________________________________
dense_1 (Dense)              (None, 64)                4160      
_________________________________________________________________
dense_2 (Dense)              (None, 7)                 455       
=================================================================
Total params: 11,975
Trainable params: 11,975
Non-trainable params: 0
_________________________________________________________________

 

データ生成

モデルを定義した今、それを訓練するためのデータが必要です。訓練セットの各サンプルについて、ランダムな 3D 回転と 3D 移動がサンプリングされて物体の頂点に適用されます。各訓練サンプルは総ての変換された頂点と (サンプルに適用された) 回転と移動を戻すことを可能にする反対の回転と移動から成ります。

def generate_training_data(num_samples):
  # random_angles.shape: (num_samples, 3)
  random_angles = np.random.uniform(-np.pi, np.pi,
                                    (num_samples, 3)).astype(np.float32)

  # random_quaternion.shape: (num_samples, 4)
  random_quaternion = quaternion.from_euler(random_angles)

  # random_translation.shape: (num_samples, 3)
  random_translation = np.random.uniform(-2.0, 2.0,
                                         (num_samples, 3)).astype(np.float32)

  # data.shape : (num_samples, num_vertices, 3)
  data = quaternion.rotate(vertices[tf.newaxis, :, :],
                           random_quaternion[:, tf.newaxis, :]
                          ) + random_translation[:, tf.newaxis, :]

  # target.shape : (num_samples, 4+3)
  target = tf.concat((random_quaternion, random_translation), axis=-1)

  return np.array(data), np.array(target)

num_samples = 10000

data, target = generate_training_data(num_samples)

print(data.shape)   # (num_samples, num_vertices, 3): the vertices
print(target.shape)  # (num_samples, 4+3): the quaternion and translation

(10000, 38, 3)
(10000, 7)

 

訓練

この時点で、ニューラルネットワークの訓練を開始するために総てが適切です！

# Callback allowing to display the progression of the training task.
class ProgressTracker(keras.callbacks.Callback):

  def __init__(self, num_epochs, step=5):
    self.num_epochs = num_epochs
    self.current_epoch = 0.
    self.step = step
    self.last_percentage_report = 0

  def on_epoch_end(self, batch, logs={}):
    self.current_epoch += 1.
    training_percentage = int(self.current_epoch * 100.0 / self.num_epochs)
    if training_percentage - self.last_percentage_report >= self.step:
      print('Training ' + str(
          training_percentage) + '% complete. Training loss: ' + str(
              logs.get('loss')) + ' | Validation loss: ' + str(
                  logs.get('val_loss')))
      self.last_percentage_report = training_percentage

reduce_lr_callback = keras.callbacks.ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.5,
    patience=10,
    verbose=0,
    mode='auto',
    min_delta=0.0001,
    cooldown=0,
    min_lr=0)

# Everything is now in place to train.
EPOCHS = 100
pt = ProgressTracker(EPOCHS)
history = model.fit(
    data,
    target,
    epochs=EPOCHS,
    validation_split=0.2,
    verbose=0,
    batch_size=32,
    callbacks=[reduce_lr_callback, pt])

plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.ylim([0, 1])
plt.legend(['loss', 'val loss'], loc='upper left')
plt.xlabel('Train epoch')
_ = plt.ylabel('Error [mean square distance]')

Training 5% complete. Training loss: 1.009950121998787 | Validation loss: 0.9137270336151123
Training 10% complete. Training loss: 0.5268501298427581 | Validation loss: 0.5240717251300812
Training 15% complete. Training loss: 0.3752533705532551 | Validation loss: 0.37031882667541505
Training 20% complete. Training loss: 0.29893275210261344 | Validation loss: 0.29115591061115265
Training 25% complete. Training loss: 0.24757031705975532 | Validation loss: 0.23939514791965485
Training 30% complete. Training loss: 0.22420285016298294 | Validation loss: 0.21258240276575088
Training 35% complete. Training loss: 0.19799123887717723 | Validation loss: 0.1807250078320503
Training 40% complete. Training loss: 0.17767862628400327 | Validation loss: 0.1784087748527527
Training 45% complete. Training loss: 0.17318876099586486 | Validation loss: 0.15155328786373137
Training 50% complete. Training loss: 0.15236466732621193 | Validation loss: 0.16674353015422821
Training 55% complete. Training loss: 0.13417977157235145 | Validation loss: 0.13277354818582535
Training 60% complete. Training loss: 0.15286476877331734 | Validation loss: 0.13142506104707719
Training 65% complete. Training loss: 0.13228631572425364 | Validation loss: 0.13619410294294357
Training 70% complete. Training loss: 0.1253597312271595 | Validation loss: 0.11984566831588746
Training 75% complete. Training loss: 0.08613634746521712 | Validation loss: 0.09534638980031014
Training 80% complete. Training loss: 0.07220880922675132 | Validation loss: 0.07457096055150032
Training 85% complete. Training loss: 0.07194197417795659 | Validation loss: 0.055152468413114546
Training 90% complete. Training loss: 0.06660718904435635 | Validation loss: 0.07816255846619606
Training 95% complete. Training loss: 0.07537854766100645 | Validation loss: 0.08529620145261288
Training 100% complete. Training loss: 0.04841766462475061 | Validation loss: 0.05356932772696018

 

テスティング

今ではネットワークは訓練されて利用する準備ができました！表示される結果は 2 つの画像から成ります。最初の画像は「静止ポーズ (= rest pose)」にある物体 (パステル・レモン色) と回転されて移動された物体 (パステル・ハニーデュー色) を含みます。これは 2 つの構成がどのように異なるかを観察することを効果的に可能にします。2 番目の画像はまた静止ポーズの物体を示しますが、今回は訓練されたニューラルネットワークにより予測された変換が回転されて移動されたバージョンに適用されます。望ましくは、2 つの物体が今では非常に類似したポーズであることです。

Note: 異なるテストケースをサンプリングするために複数回プレーを押してください。貴方は時々物体のスケーリングが無効であることに気付くでしょう。これはクォータニオンがスケールをエンコードできるという事実に由来します。単位ノルムのクォータニオンの使用は結果のスケールを変更しないという結果になるでしょう。ネットワーク・アーキテクチャか損失関数でこの制約を追加する実験を興味ある読者に委ねます。

クォータニオンと移動を適用するヘルパー関数から始めます :

# Defines the loss function to be optimized.
def transform_points(target_points, quaternion_variable, translation_variable):
  return quaternion.rotate(target_points,
                           quaternion_variable) + translation_variable

変換された形状のための threejs ビューアを定義します :

class Viewer(object):

  def __init__(self, my_vertices):
    my_vertices = np.asarray(my_vertices)
    context = threejs_visualization.build_context()
    light1 = context.THREE.PointLight.new_object(0x808080)
    light1.position.set(10., 10., 10.)
    light2 = context.THREE.AmbientLight.new_object(0x808080)
    lights = (light1, light2)

    material = context.THREE.MeshLambertMaterial.new_object({
        'color': 0xfffacd,
    })

    material_deformed = context.THREE.MeshLambertMaterial.new_object({
        'color': 0xf0fff0,
    })

    camera = threejs_visualization.build_perspective_camera(
        field_of_view=30, position=(10.0, 10.0, 10.0))

    mesh = {'vertices': vertices, 'faces': faces, 'material': material}
    transformed_mesh = {
        'vertices': my_vertices,
        'faces': faces,
        'material': material_deformed
    }
    geometries = threejs_visualization.triangular_mesh_renderer(
        [mesh, transformed_mesh],
        lights=lights,
        camera=camera,
        width=400,
        height=400)

    self.geometries = geometries

  def update(self, transformed_points):
    self.geometries[1].getAttribute('position').copyArray(
        transformed_points.numpy().ravel().tolist())
    self.geometries[1].getAttribute('position').needsUpdate = True

ランダム回転と移動を定義します :

def get_random_transform():
  # Forms a random translation
  with tf.name_scope('translation_variable'):
    random_translation = tf.Variable(
        np.random.uniform(-2.0, 2.0, (3,)), dtype=tf.float32)

  # Forms a random quaternion
  hi = np.pi
  lo = -hi
  random_angles = np.random.uniform(lo, hi, (3,)).astype(np.float32)
  with tf.name_scope('rotation_variable'):
    random_quaternion = tf.Variable(quaternion.from_euler(random_angles))

  return random_quaternion, random_translation

変換パラメータを予測するモデルを実行して、結果を可視化します :

random_quaternion, random_translation = get_random_transform()

initial_orientation = transform_points(vertices, random_quaternion,
                                       random_translation).numpy()
viewer = Viewer(initial_orientation)

predicted_transformation = model.predict(initial_orientation[tf.newaxis, :, :])

predicted_inverse_q = quaternion.inverse(predicted_transformation[0, 0:4])
predicted_inverse_t = -predicted_transformation[0, 4:]

predicted_aligned = quaternion.rotate(initial_orientation + predicted_inverse_t,
                                      predicted_inverse_q)

viewer = Viewer(predicted_aligned)

 
(訳注 : 幾つかの実行サンプルを以下に示します : )

 

2. 数学的最適化

ここでは問題は数学的最適化を使用して取り組まれます、これは物体ポーズ推定の問題にアプローチするためのもう一つの伝統的な方法です。「静止ポーズ」にある物体 (パステルレモン色) とその回転されて移動された対応物体 (パステルハニーデュー色) 間の対応が与えられたとき、問題は最小化問題として定式化できます。損失関数は例えば、変換された物体の回転と移動の現在の推定を使用して対応する点のユークリッド距離の総計として定義できます。そしてこの損失に関する回転と移動パラメータの導関数を計算して、収束まで勾配方向をフォローできます。次のセルはこの手続きを密接にフォローし、そして 2 つの物体を整列するために勾配効果を使用します。結果は良いですが、注目すべき点としてこの特定の問題を解くためにより効率的な方法があります。興味ある読者はより詳細について Kabsch アルゴリズムを参照してください。

Note: 異なるテストケースをサンプリングするために複数回プレーを押してください。

損失と勾配関数を定義します :

def loss(target_points, quaternion_variable, translation_variable):
  transformed_points = transform_points(target_points, quaternion_variable,
                                        translation_variable)
  error = (vertices - transformed_points) / num_vertices
  return vector.dot(error, error)


def gradient_loss(target_points, quaternion, translation):
  with tf.GradientTape() as tape:
    loss_value = loss(target_points, quaternion, translation)
  return tape.gradient(loss_value, [quaternion, translation])

optimizer を作成します。

learning_rate = 0.05
with tf.name_scope('optimization'):
  optimizer = tf.train.AdamOptimizer(learning_rate)

ランダム変換を初期化して、最適化を実行して結果をアニメーションにします。

random_quaternion, random_translation = get_random_transform()

transformed_points = transform_points(vertices, random_quaternion,
                                      random_translation)

viewer = Viewer(transformed_points)

nb_iterations = 100
for it in range(nb_iterations):
  gradients_loss = gradient_loss(vertices, random_quaternion,
                                 random_translation)
  optimizer.apply_gradients(
      zip(gradients_loss, (random_quaternion, random_translation)))
  transformed_points = transform_points(vertices, random_quaternion,
                                        random_translation)

  viewer.update(transformed_points)
  time.sleep(0.1)

以上