将每个张量值映射到列表中最接近的值答案

【问题标题】：Map each tensor value to the closest value in a list将每个张量值映射到列表中最接近的值
【发布时间】：2019-05-26 03:39:12
【问题描述】：

我有一个张量A，大小为[batchSize,2,2,2]，其中batchSize 是一个占位符。在自定义层中，我想将此张量的每个值映射到长度为n 的列表c 中最接近的值。该列表是我的密码本，我想根据此密码本量化张量中的每个值；即找到与列表中每个张量值最接近的值，并将张量值替换为该值。我想不出一个“干净”的张量运算可以快速做到这一点。我无法遍历batchSize。 Tensorflow 中有没有办法做到这一点？

【问题讨论】：

你能举一个你的密码本的例子吗？如果是标准的最小-最大量化，也许你可以使用https://www.tensorflow.org/api_docs/python/tf/quantization/quantize。或者，如果您有一些键值对，您可能首先进行一些规范化，然后通过 tf.contrib.lookup.HashTable 执行键/值查找。
@greeness 感谢您的回复。 tf.quantization.quantize 对我不起作用，因为我的量化值不均匀。我认为哈希表也不适合我，因为我从高斯分布中随机抽取张量 A 的值。码本c 向量包括来自长度为100 的高斯分布的非均匀量化值。因此，我将从连续分布中随机抽取的值映射到量化值。

标签： python tensorflow keras quantization

【解决方案1】：

如果我理解正确，tf.HashTable 可以做到这一点。作为说明，我使用了mean=0, stddev=4 的正态分布。

a = tf.random.normal(
  shape = [batch, 2, 2, 2],
  mean=0.0,
  stddev=4
)

而且我使用了只有 5 个桶的量化（参见图中标有数字 0、1、2、3、4 的图）。这可以扩展到任何长度n。请注意，我故意使存储桶具有可变长度。

因此，我的密码本是：

a <= -2          -> bucket 4
-2 < a < -0.5    -> bucket 3
-0.5 <= a < 0.5  -> bucket 0
0.5 <= a < 2.5   -> bucket 1
a >= 2.5         -> bucket 2

这个想法是预先创建一个从缩放的a 到存储桶编号的键/值映射。（<key,value> 对的数量取决于您需要的输入粒度。这里我缩放了 10）。下面是初始化映射表和生成的映射（输入缩放 10）的代码。

# The boundary is chosen based on that we clip by min=-4, max=4. 
# after scaling, the boundary becomes -40 and 40. 
keys = range(-40, 41)
values  = []
for k in keys:
  if k <= -20:
    values.append(4)
  elif k < -5:
    values.append(3)
  elif k < 5:
    values.append(0)
  elif k < 25:
    values.append(1)
  else:
    values.append(2)
for (k, v) in zip(keys, values):
  print ("%2d -> %2d" % (k, v))


-40 ->  4
-39 ->  4
...
-22 ->  4
-21 ->  4
-20 ->  4
-19 ->  3
-18 ->  3
...
-7 ->  3
-6 ->  3
-5 ->  0
-4 ->  0
...
 3 ->  0
 4 ->  0
 5 ->  1
 6 ->  1
 ...
23 ->  1
24 ->  1
25 ->  2
26 ->  2
...
40 ->  2

batch = 3
a = tf.random.normal(
    shape = [batch, 2, 2, 2],
    mean=0.0,
    stddev=4,
    dtype=tf.dtypes.float32
)
clip_a = tf.clip_by_value(a, clip_value_min=-4, clip_value_max=4)
SCALE = 10
scaled_clip_a = tf.cast(clip_a * SCALE, tf.int32)

table = tf.contrib.lookup.HashTable(
    tf.contrib.lookup.KeyValueTensorInitializer(keys, values), -1)
quantized_a = tf.reshape(
    table.lookup(tf.reshape(scaled_clip_a, [-1])), 
    [batch, 2, 2, 2])

with tf.Session() as sess:
  table.init.run()
  a, clip_a, scaled_clip_a, quantized_a = sess.run([a, clip_a, scaled_clip_a, quantized_a])
  print ('a\n%s' % a)
  print ('clip_a\n%s' % clip_a)
  print ('scaled_clip_a\n%s' % scaled_clip_a)
  print ('quantized_a\n%s' % quantized_a)

结果：

a
[[[[-0.26980758 -5.56331968]
   [ 5.04240322 -7.18292665]]

  [[-7.11545467 -3.24369478]
   [ 1.01861215 -0.04510783]]]


 [[[-0.28768024  0.2472897 ]
   [ 2.17780781 -5.79106379]]

  [[ 8.45582008  4.53902292]
   [ 0.138162   -6.19155598]]]


 [[[-7.5134449   4.56302166]
   [-0.30592337 -0.60313278]]

  [[-0.06204566  3.42917275]
   [-1.14547718  3.31167102]]]]
clip_a
[[[[-0.26980758 -4.        ]
   [ 4.         -4.        ]]

  [[-4.         -3.24369478]
   [ 1.01861215 -0.04510783]]]


 [[[-0.28768024  0.2472897 ]
   [ 2.17780781 -4.        ]]

  [[ 4.          4.        ]
   [ 0.138162   -4.        ]]]


 [[[-4.          4.        ]
   [-0.30592337 -0.60313278]]

  [[-0.06204566  3.42917275]
   [-1.14547718  3.31167102]]]]
scaled_clip_a
[[[[ -2 -40]
   [ 40 -40]]

  [[-40 -32]
   [ 10   0]]]


 [[[ -2   2]
   [ 21 -40]]

  [[ 40  40]
   [  1 -40]]]


 [[[-40  40]
   [ -3  -6]]

  [[  0  34]
   [-11  33]]]]
quantized_a
[[[[0 4]
   [2 4]]

  [[4 4]
   [1 0]]]


 [[[0 0]
   [1 4]]

  [[2 2]
   [0 4]]]


 [[[4 2]
   [0 3]]

  [[0 2]
   [3 2]]]]

【讨论】：