Выполнение парного вычисления расстояния с помощью TensorFlow

В скором времени я хочу сделать вычисление попарного расстояния для функций каждой мини-партии и вставить эту потерю в общую потерю сети. У меня есть только Tesnor партии (16 выборок), тензор меток партии и тензода функции партии.

После долгого поиска я все еще не мог понять следующее:

1) Как разделить пакет для Positive (например, той же метки) и отрицательных пар. Поскольку Tensor не итеративно, я не могу понять, как получить, какой образец имеет метку, а затем разделить мой вектор или получить, какие индексы тензора принадлежат каждому классу.

2) Как я могу сделать вычисление попарного расстояния для некоторых индексов в тензоре партии?

3) Мне также необходимо определить новую функцию расстояния для отрицательных примеров

В целом, мне нужно получить, какие индексы принадлежат классу, сделать положительный параллельный расчет для всех положительных пар. И сделайте еще один расчет для всех отрицательных пар. Затем суммируйте все это и добавьте в сетевую потерю.

Любая помощь (к одной из трех проблем) была бы высоко оценена.

Ответы

Ответ 1

1) Вы должны сделать пару образцов до, подавая данные в сеанс. Обозначьте каждую пару логической меткой, например y = 1 для пары с совпадением, 0 в противном случае.

2) 3) Просто вычислите оба параметра pos/neg для каждой пары и дайте метке 0-1 y выбрать, что добавить к убытку.

Сначала создайте заполнители, y_ - для логических меток.

dim = 64
x1_ = tf.placeholder('float32', shape=(None, dim))
x2_ = tf.placeholder('float32', shape=(None, dim))
y_ = tf.placeholder('uint8', shape=[None])   # uint8 for boolean

Тогда тензор потерь может быть создан функцией.

def loss(x1, x2, y):
    # Euclidean distance between x1,x2
    l2diff = tf.sqrt( tf.reduce_sum(tf.square(tf.sub(x1, x2)),
                                    reduction_indices=1))

    # you can try margin parameters
    margin = tf.constant(1.)     

    labels = tf.to_float(y)

    match_loss = tf.square(l2diff, 'match_term')
    mismatch_loss = tf.maximum(0., tf.sub(margin, tf.square(l2diff)), 'mismatch_term')

    # if label is 1, only match_loss will count, otherwise mismatch_loss
    loss = tf.add(tf.mul(labels, match_loss), \
                  tf.mul((1 - labels), mismatch_loss), 'loss_add')

    loss_mean = tf.reduce_mean(loss)
    return loss_mean

loss_ = loss(x1_, x2_, y_)

Затем подайте ваши данные (например, сгенерированные случайным образом):

batchsize = 4
x1 = np.random.rand(batchsize, dim)
x2 = np.random.rand(batchsize, dim)
y = np.array([0,1,1,0])

l = sess.run(loss_, feed_dict={x1_:x1, x2_:x2, y_:y})

Ответ 2

Короткий ответ

Я думаю, что самый простой способ сделать это: отбирать пары в автономном режиме (т.е. вне графика TensorFlow).
Вы создаете tf.placeholder для партии пар вместе со своими метками (положительными или отрицательными, то есть тем же классом или другим классом), а затем вы можете вычислить в TensorFlow соответствующую потерю.

С кодом

Вы выбираете пары в автономном режиме. Вы выбираете пары batch_size и вводите batch_size левые элементы пар формы [batch_size, input_size]. Вы также выводите метки пар (либо положительных отрицательных) формы [batch_size,]

pairs_left = np.zeros((batch_size, input_size))
pairs_right = np.zeros((batch_size, input_size))
labels = np.zeros((batch_size, 1))  # ex: [[0.], [1.], [1.], [0.]] for batch_size=4

Затем вы создаете заполнители Tensorflow, соответствующие этим входам. В вашем коде вы будете кормить предыдущие входы этих заполнителей в аргументе feed_dict sess.run()

pairs_left_node = tf.placeholder(tf.float32, [batch_size, input_size])
pairs_right_node = tf.placeholder(tf.float32, [batch_size, input_size])
labels_node = tf.placeholder(tf.float32, [batch_size, 1])

Теперь мы можем выполнить форматирование на входах (допустим, ваша модель является линейной моделью).

W = ...   # shape [input_size, feature_size]
output_left = tf.matmul(pairs_left_node, W)  # shape [batch_size, feature_size]
output_right = tf.matmul(pairs_right_node, W)  # shape [batch_size, feature_size]

Наконец, мы можем вычислить парную потерю.

l2_loss_pairs = tf.reduce_sum(tf.square(output_left - output_right), 1)
positive_loss = l2_loss_pairs
negative_loss = tf.nn.relu(margin - l2_loss_pairs)
final_loss = tf.mul(labels_node, positive_loss) + tf.mul(1. - labels_node, negative_loss)

И это! Теперь вы можете оптимизировать эту потерю с хорошей автономной выборкой.