tf.nn.embedding_lookup_sparse

Ищет вложения для заданных идентификаторов и весов из списка тензоров.

tf.nn.embedding_lookup_sparse(
    params,
    sp_ids,
    sp_weights,
    combiner=None,
    max_norm=None,
    name=None,
    allow_fast_lookup=False
)

params — это плотный тензор или список плотных тензоров, а sp_ids — 2D tf.SparseTensor или tf.RaggedTensor, указывающий на индексы params для сбора.

Этот оператор лучше всего описать на примере. Предположим, что params — это таблица вложений размера (4, 2), а sp_ids имеет 3 строки. Поскольку sp_ids является разреженным или разрозненным, не каждая строка имеет одинаковое количество элементов. Результирующий тензор имеет форму (3, 2). Каждая строка sp_ids представляет собой список индексов, где каждый индекс выбирает строку из params. Для данной строки из sp_ids строки params собираются на основе индексов в sp_ids, а затем объединяются, вычисляя сумму или среднее.

params = tf.constant([[1, 2], [3, 4], [5, 6], [7, 8]], dtype=tf.float32)
sp_ids = tf.SparseTensor(indices=[[0, 0], [0, 1], [1, 0], [2, 0]],
                         values=[0, 1, 3, 2], dense_shape=(3, 2))
tf.nn.embedding_lookup_sparse(params, sp_ids, sp_weights=None,
                              combiner='sum').numpy()
array([[4., 6.], [7., 8.], [5., 6.]], dtype=float32)

В этом примере sp_ids имеет 3 строки, поэтому выходной тензор имеет 3 строки. Строка 0 из sp_ids содержит значения 0 и 1, поэтому она выбирает строки 0 и 1 из params, которые равны [1, 2] и [3, 4]. Строки суммируются, поскольку combiner='sum', что приводит к выходной строке [4, 6].

Так как строки 1 и 2 из sp_ids содержат только одно значение каждая, они просто выбирают соответствующую строку из params в качестве выходной строки. Строка 1 имеет значение 3, поэтому она выбирает элементы params [7, 8], а строка 2 имеет значение 2, поэтому она выбирает элементы params [5, 6].

Если задан sparse_weights, он должен иметь ту же форму, что и sp_ids. sparse_weights используется для присвоения весов каждому фрагменту params. Например:

params = tf.constant([[1, 2], [3, 4], [5, 6], [7, 8]], dtype=tf.float32)
sp_ids = tf.SparseTensor(indices=[[0, 0], [0, 1], [1, 0], [2, 0]],
                         values=[0, 1, 3, 2], dense_shape=(3, 2))
sparse_weights = tf.SparseTensor(indices=[[0, 0], [0, 1], [1, 0], [2, 0]],
                                 values=[0.1, 1.0, 0.5, 2.0],
                                 dense_shape=(3, 2))
tf.nn.embedding_lookup_sparse(params, sp_ids, sp_weights=sparse_weights,
                              combiner='sum').numpy()
array([[3.1, 4.2], [3.5, 4.], [10., 12.]], dtype=float32)

В общем случае, params может иметь форму (p0, ..., pn), а sp_ids может иметь M строк, где каждая строка может иметь любое количество элементов. Выходной тензор имеет форму (M, p1, ..., pn). Каждый фрагмент выходного тензора output[i, ...] вычисляется следующим образом: аргумент combiner используется для объединения значений params[sp_ids[i, j], ...] * sparse_weights[i, j] для каждого j в range(0, len(sp_ids[i])), например, вычислением суммы или среднего значения.

Этот оператор предполагает, что для каждой строки в плотном тензоре, представленном sp_ids, есть хотя бы один идентификатор (т. е. нет строк с пустыми признаками), и что все индексы sp_ids расположены в каноническом порядке строк.

sp_ids и sp_weights (если не None) являются SparseTensor или RaggedTensor с рангом 2. Для SpareTensor с левосторонними ненулевыми элементами, которые можно описать как RaggedTensor, использование RaggedTensor может повысить производительность.

Этот оператор предполагает, что все значения id лежат в диапазоне [0, p0), где p0 — это params.shape[0]. Если требуется версия этого оператора, которая обрезает значения id, меньшие 0, см. tf.nn.safe_embedding_lookup_sparse

Если len(params) > 1, каждый элемент sp_ids разделяется между элементами params в соответствии с «div» стратегией разделения, что означает, что мы присваиваем id разделам в непрерывном порядке. Например, 13 id разделены на 5 разделов следующим образом: [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10], [11, 12]].

Если пространство id не делится равномерно на количество разделов, каждому из первых (max_id + 1) % len(params) разделов будет присвоен еще один id.

[0, 0]: id 1, weight 2.0
[0, 1]: id 3, weight 0.5
[1, 0]: id 0, weight 1.0
[2, 3]: id 1, weight 3.0

output[0, :] = (params[1, :] * 2.0 + params[3, :] * 0.5) / (2.0 + 0.5)
output[1, :] = (params[0, :] * 1.0) / 1.0
output[2, :] = (params[1, :] * 3.0) / 3.0