Question

我想创建一个tensorflow函数，它复制我的三维张量中每个二维矩阵的euclidean distance transform scipy。

我有一个三维张量，其中第三轴代表一个热门编码的特征。我想为每个要素维创建一个矩阵，其中每个单元格中的值等于到最近要素的距离。

示例：

input = [[1 0 0]
         [0 1 0]
         [0 0 1],

         [0 1 0]
         [0 0 0]
         [1 0 0]]

output = [[0    1   1.41]
          [1    0   1   ]
          [1.41 1   0   ],

          [1    0   1   ]
          [1    1   1.41]
          [0    1   2   ]]

我目前的解决方案是在python中实现的。该方法遍历要素维度的每个单元格，在单元格周围创建环并搜索环是否包含要素。然后，它计算单元格到每个要素条目的距离，并采用最小值。如果环不包含其中包含特征的单元格，则搜索环会变宽。

代码：

import numpy as np
import math

def distance_matrix():
    feature_1 = np.eye(5)
    feature_2 = np.array([[0, 1, 0, 0, 0],
                  [0, 0, 0, 0, 0],
                  [0, 0, 0, 0, 0],
                  [1, 0, 0, 0, 0],
                  [0, 0, 0, 0, 0],])
    ground_truth = np.stack((feature_1,feature_2), axis=2)
    x = np.zeros(ground_truth.shape)

    for feature_index in range(ground_truth.shape[2]):
        for i in range(ground_truth.shape[0]):
            for j in range(ground_truth.shape[1]):
                x[i,j,feature_index] = search_ring(i,j, feature_index,0,ground_truth)
    print(x[:,:,0])

def search_ring(i, j,feature_index, ring_size, truth):
    if ring_size == 0 and truth[i,j,feature_index] == 1.:
                    return 0
    else:
        distance = truth.shape[0]
        y_min = max(i - ring_size, 0)
        y_max = min(i + ring_size, truth.shape[0] - 1)
        x_min = max(j - ring_size, 0)
        x_max = min(j + ring_size, truth.shape[1] - 1)

        if truth[y_min:y_max+1, x_min:x_max+1, feature_index].sum() > 0:
            for y in range(y_min, y_max + 1):
                for x in range(x_min, x_max + 1):
                    if y == y_min or y == y_max or x == x_min or x == x_max:
                        if truth[y,x,feature_index] == 1.:
                            dist = norm(i,j,y,x,type='euclidean')
                            distance = min(distance, dist)
            return distance
        else:
            return search_ring(i, j,feature_index, ring_size + 1, truth)

def norm(index_y_a, index_x_a, index_y_b, index_x_b, type='euclidean'):
    if type == 'euclidean':
        return math.sqrt(abs(index_y_a - index_y_b)**2 + abs(index_x_a - index_x_b)**2)
    elif type == 'manhattan':
        return abs(index_y_a - index_y_b) + abs(index_x_a - index_x_b)


def main():
    distance_matrix()
if __name__ == '__main__':
    main()

我的问题是在Tensorflow中复制这个，因为我需要它在Keras中的自定义丢失功能。如何访问我正在迭代的项目的索引？

Answer 1

我没有看到你在keras中使用距离变换的任何问题，基本上，你需要的只是tf.py_func，它将现有的python函数包装到tensorflow运算符。

但是，我认为这里的根本问题是关于反向传播。您的模型在前向传递中会有任何问题，但您希望传播的是什么渐变？或者你根本就不关心它的渐变。

Answer 2

我使用py_func完成了与scipy类似的操作，以创建带符号的距离变换。以下是您的情况：

import scipy.ndimage.morphology as morph
arrs = []
for channel_index in range(C):
    arrs.append(tf.py_func(morph.distance_transform_edt, [tensor[..., channel_index]], tf.float32))
edt_tf = tf.stack(arrs, axis=-1)

请注意py_func的限制：它们不会被序列化为GraphDefs，因此它会默默地在您保存的模型中序列化函数体。请参阅tf.py_func documentation。

张量流中的欧几里德距离变换

2 个答案: