python之tensorflow 中的 output_data[output_ids == i] = input_data[input_ids == i]

在numpy代码中，如果你想让相同的id得到相同的值，你可以例如:

input_data = np.array([0.1, 0.2, 0.3]) 
input_ids = np.array([0, 1, 2]) 
output_ids = np.array([2, 0, 1, 0]) 
output_data = np.array([0.1, 0.1, 0.1, 0.1]) 
for i in input_ids: 
    output_data[output_ids == i] = input_data[input_ids == i] 
print(output_data) 

输出:[0.3 0.1 0.2 0.1]

注意:input_ids = unique(input_ids)，一开始就是唯一的。

在tensorflow中，我如何执行这种代码，我应该使用哪个功能。有没有类似的例子？

• input_data:张量，可以是float64、float 32

• output_data:张量，与input_data类型相同

• input_ids:张量，必须是 int32 或 int64。

• output_ids:张量，必须是 int32 或 int64。

请您参考如下方法:

我将按照复杂性递增的顺序为您提供几个选项。在最简单的情况下，input_ids 始终是从 0 开始的整数序列，对应于 input_data 的索引 ([0, 1 , 2, ...]).在这种情况下，您可以简单地执行以下操作:

import tensorflow as tf 
 
with tf.Graph().as_default(), tf.Session() as sess: 
    input_data = tf.constant([0.1, 0.2, 0.3]) 
    output_ids = tf.constant([2, 0, 1, 0]) 
    output_data = tf.gather(input_data, output_ids) 
    print(sess.run(output_data)) 
    # [0.3 0.1 0.2 0.1] 

如果input_ids与input_data的索引不对应，但仍按升序排列，可以这样做:

import tensorflow as tf 
 
with tf.Graph().as_default(), tf.Session() as sess: 
    input_data = tf.constant([0.1, 0.2, 0.3]) 
    input_ids = tf.constant([-2, 0, 4]) 
    output_ids = tf.constant([4, -2, 0, -2]) 
    output_idx = tf.searchsorted(input_ids, output_ids) 
    output_data = tf.gather(input_data, output_idx) 
    print(sess.run(output_data)) 
    # [0.3 0.1 0.2 0.1] 

最一般的情况是 input_ids 是一个未排序的整数数组。在这种情况下，您可以这样做:

import tensorflow as tf 
 
with tf.Graph().as_default(), tf.Session() as sess: 
    input_data = tf.constant([0.1, 0.2, 0.3]) 
    input_ids = tf.constant([3, 1, 6]) 
    output_ids = tf.constant([6, 3, 1, 3]) 
    # From TF v1.13 
    s = tf.argsort(input_ids) 
    # Before TF v1.13 
    s = tf.contrib.framework.argsort(input_ids) 
    output_idx_s = tf.searchsorted(tf.gather(input_ids, s), output_ids) 
    output_data = tf.gather(input_data, tf.gather(s, output_idx_s)) 
    print(sess.run(output_data)) 
    # [0.3 0.1 0.2 0.1] 

当然，在所有情况下，您都可以使用将 input_ids 中的每个值与 output_ids 中的每个值进行比较的二次解。我会写在下面以供引用，但在时间和内存上都比以前的效率低，所以真的没有理由更喜欢它。

import tensorflow as tf 
 
with tf.Graph().as_default(), tf.Session() as sess: 
    input_data = tf.constant([0.1, 0.2, 0.3]) 
    input_ids = tf.constant([3, 1, 6]) 
    output_ids = tf.constant([6, 3, 1, 3]) 
    eq = tf.equal(tf.expand_dims(output_ids, 1), input_ids) 
    output_idx = tf.argmax(tf.cast(eq, tf.int8), axis=1) 
    output_data = tf.gather(input_data, output_idx) 
    print(sess.run(output_data)) 
    # [0.3 0.1 0.2 0.1] 

编辑:作为giser_yugang指出，也可能存在 output_ids 中并非所有值都在 input_ids 中的情况。在这种情况下，将使用 output_data 的初始值。你可以用这样的东西来实现它:

import tensorflow as tf 
 
with tf.Graph().as_default(), tf.Session() as sess: 
    input_data = tf.constant([0.1, 0.2, 0.3]) 
    input_ids = tf.constant([3, 1, 6]) 
    output_data = tf.constant([0., 0., 0., 0., 0.]) 
    output_ids = tf.constant([6, 3, 1, 3, 0]) 
    # From TF v1.13 
    s = tf.argsort(input_ids) 
    # Before TF v1.13 
    s = tf.contrib.framework.argsort(input_ids) 
    input_ids_s = tf.gather(input_ids, s) 
    n = tf.size(input_ids) 
    output_idx_s = tf.minimum(tf.searchsorted(input_ids_s, output_ids), n - 1) 
    output_data = tf.where(tf.equal(output_ids, tf.gather(input_ids_s, output_idx_s)), 
                           tf.gather(input_data, tf.gather(s, output_idx_s)), 
                           output_data) 
    print(sess.run(output_data)) 
    # [0.3 0.1 0.2 0.1 0. ]