tf.sparse.bincount

Подсчитывает количество вхождений целочисленного значения в тензоре.

Просмотр псевдонимов

Псевдонимы совместимости для миграции

См. Руководство по миграции для получения более подробной информации.

tf.compat.v1.sparse.bincount

tf.sparse.bincount(
    values,
    weights=None,
    axis=0,
    minlength=None,
    maxlength=None,
    binary_output=False,
    name=None
)

Этот оператор принимает N-мерный Tensor, RaggedTensor или SparseTensor и возвращает N-мерный int64 SparseTensor, где элемент [i0...i[axis], j] содержит количество раз, которое значение j появляется в срезе [i0...i[axis], :] входного тензора. В настоящее время поддерживаются только N=0 и N=-1.

Аргументы
`values`	Тензор, RaggedTensor или SparseTensor, значения которых необходимо подсчитать. Эти тензоры должны иметь ранг 2, если `axis=-1`.
`weights`	Если не None, должно быть того же размера, что и `arr`. Если `arr` является SparseTensor, то `weights` должен быть SparseTensor с такой же плотной формой и теми же индексами, что и `arr`. Для каждого значения в `value` счёт увеличивается на соответствующее значение веса, а не на 1.
`axis`	Ось для среза. Оси на и ниже `axis` будут уплощены перед подсчетом. В настоящее время поддерживаются только `0` и `-1`. Если None, все оси будут уплощены (что идентично передаче `0`).
`minlength`	Если задано, гарантирует, что вывод имеет длину как минимум `minlength`, заполняя нулями в конце, если необходимо.
`maxlength`	Если задано, пропускает значения в `values`, которые равны или больше `maxlength`, гарантируя, что вывод имеет длину не более `maxlength`.
`binary_output`	Если True, этот оператор будет выводить 1 вместо количества вхождений токена (что эквивалентно one_hot + reduce_any вместо one_hot + reduce_add). По умолчанию False.
`name`	Имя для этого оператора.

Возвращаемое значение
SparseTensor с `output.shape = values.shape[:axis] + [N]`, где `N` — `maxlength` (если задано); `minlength` (если задано и `minlength > reduce_max(values)`); `0` (если `values` пусто); `reduce_max(values) + 1` в противном случае.

Исключения
`InvalidArgumentError` если в качестве входных данных предоставлены отрицательные значения.

Примеры:

Подсчёт каждого элемента в отдельных группах

data = np.array([[10, 20, 30, 20], [11, 101, 11, 10001]], dtype=np.int64)
tf.sparse.bincount(data, axis=-1)
SparseTensor(indices=tf.Tensor(
[[    0    10]
 [    0    20]
 [    0    30]
 [    1    11]
 [    1   101]
 [    1 10001]], shape=(6, 2), dtype=int64),
 values=tf.Tensor([1 2 1 2 1 1], shape=(6,), dtype=int64),
 dense_shape=tf.Tensor([    2 10002], shape=(2,), dtype=int64))

Этот пример демонстрирует входной SparseTensor. Пропущенные нули не учитываются.

data = tf.sparse.SparseTensor(
    indices=[[0, 3], [0, 7], [0, 8], [0, 11],
             [1, 9], [1, 11], [1, 18], [1, 27]],
    values=[10, 20, 30, 20, 11, 101, 11, 10001],
    dense_shape=[2, 30])
tf.sparse.bincount(data, axis=-1)
SparseTensor(indices=tf.Tensor(
[[    0    10]
 [    0    20]
 [    0    30]
 [    1    11]
 [    1   101]
 [    1 10001]], shape=(6, 2), dtype=int64),
 values=tf.Tensor([1 2 1 2 1 1], shape=(6,), dtype=int32),
 dense_shape=tf.Tensor([    2 10002], shape=(2,), dtype=int64))

Подсчёт с определённым размером результата

Этот пример принимает входные данные (который может быть тензором, RaggedTensor или SparseTensor) и возвращает SparseTensor, где значение (i, j) — количество раз, когда значение j появляется в группе i. Однако все значения j выше 'maxlength' игнорируются. Плотная форма выходного SparseTensor устанавливается в 'minlength'. Обратите внимание, что, хотя входные данные идентичны примеру выше, значение '10001' в элементе группы 2 отбрасывается, а плотная форма имеет размер [2, 500] вместо [2, 10002] или [2, 102].

minlength = maxlength = 500
data = np.array([[10, 20, 30, 20], [11, 101, 11, 10001]], dtype=np.int64)
tf.sparse.bincount(
   data, axis=-1, minlength=minlength, maxlength=maxlength)
SparseTensor(indices=tf.Tensor(
[[  0  10]
 [  0  20]
 [  0  30]
 [  1  11]
 [  1 101]], shape=(5, 2), dtype=int64),
 values=tf.Tensor([1 2 1 2 1], shape=(5,), dtype=int64),
 dense_shape=tf.Tensor([  2 500], shape=(2,), dtype=int64))

Двоичный подсчёт

Этот пример принимает входные данные (который может быть тензором, RaggedTensor или SparseTensor) и возвращает SparseTensor, где (i, j) равно 1, если значение j появляется в группе i хотя бы один раз, и 0 в противном случае. Обратите внимание, что, хотя некоторые значения (например, 20 в группе 1 и 11 в группе 2) появляются более одного раза, тензор `values` содержит только 1.

data = np.array([[10, 20, 30, 20], [11, 101, 11, 10001]], dtype=np.int64)
tf.sparse.bincount(data, binary_output=True, axis=-1)
SparseTensor(indices=tf.Tensor(
[[    0    10]
 [    0    20]
 [    0    30]
 [    1    11]
 [    1   101]
 [    1 10001]], shape=(6, 2), dtype=int64),
 values=tf.Tensor([1 1 1 1 1 1], shape=(6,), dtype=int64),
 dense_shape=tf.Tensor([    2 10002], shape=(2,), dtype=int64))

Взвешенный подсчёт

Этот пример принимает два входных тензора — тензор значений и тензор весов. Эти тензоры должны иметь одинаковую форму и одинаковые строки или индексы в случае RaggedTensor или SparseTensor. При выполнении взвешенного подсчёта оператор выведет SparseTensor, где значение (i, j) — сумма значений в тензоре весов в группе i в местах, где тензор значений имеет значение j. В этом случае тип данных вывода совпадает с типом данных тензора весов.

data = np.array([[10, 20, 30, 20], [11, 101, 11, 10001]], dtype=np.int64)
weights = [[2, 0.25, 15, 0.5], [2, 17, 3, 0.9]]
tf.sparse.bincount(data, weights=weights, axis=-1)
SparseTensor(indices=tf.Tensor(
[[    0    10]
 [    0    20]
 [    0    30]
 [    1    11]
 [    1   101]
 [    1 10001]], shape=(6, 2), dtype=int64),
 values=tf.Tensor([2. 0.75 15. 5. 17. 0.9], shape=(6,), dtype=float32),
 dense_shape=tf.Tensor([    2 10002], shape=(2,), dtype=int64))

© 2022 The TensorFlow Authors. All rights reserved.
Licensed under the Creative Commons Attribution License 4.0.
Code samples licensed under the Apache 2.0 License.
https://www.tensorflow.org/api_docs/python/tf/sparse/bincount