tf.RaggedTensor

Представляет разряженный тензор.

tf.RaggedTensor(
    values, row_partition, internal=False
)

Разряженный тензор — это тензор с одной или несколькими разряженными измерениями, которые являются измерениями, срезы которых могут иметь разную длину. Например, внутреннее (столбцовое) измерение тензора rt=[[3, 1, 4, 1], [], [5, 9, 2], [6], []] разряженное, так как столбцовые срезы (rt[0, :], ..., rt[4, :]) имеют разную длину. Измерения, срезы которых имеют одинаковую длину, называются однородными измерениями. Наружное измерение разряженного тензора всегда однородное, так как состоит из одного среза (и поэтому нет возможности для различающихся длин срезов).

Общее количество измерений в разряженном тензоре называется его рангом, а количество разряженных измерений в разряженном тензоре называется его рангом разряженности. Ранг разряженности разряженного тензора фиксируется во время создания графа: он не может зависеть от значений Tensor во время выполнения и не может изменяться динамически для разных запусков сеанса.

Возможные разряженные тензоры

Многие операции поддерживают как разряженные тензоры, так и обычные тензоры. Термин «потенциально разряженный тензор» может использоваться для обозначения тензора, который может быть либо разряженным, либо обычным. Ранг разряженности потенциально разряженного тензора равен нулю.

Документирование форм RaggedTensor

При документировании формы разряженного тензора разряженные измерения могут быть указаны, заключив их в скобки. Например, форма 3-мерного разряженного тензора, хранящего вложенный вектор слов фиксированного размера для каждого слова в предложении, для каждого предложения в пакете, может быть записана как [num_sentences, (num_words), embedding_size]. Скобки вокруг (num_words) указывают, что это измерение разряжено, и что длина каждого элемента списка в этом измерении может различаться для каждого элемента.

Компонентные тензоры

Внутри разряженный тензор состоит из конкатенированного списка значений, которые разделены на строки переменной длины. В частности, каждый разряженный тензор состоит из:

• Тензора values, который конкатенирует строки переменной длины в сплошной список. Например, тензор values для [[3, 1, 4, 1], [], [5, 9, 2], [6], []] равен [3, 1, 4, 1, 5, 9, 2, 6].

• Вектора row_splits, который указывает, как эти сплошные значения разделяются на строки. В частности, значения для строки rt[i] хранятся в срезе rt.values[rt.row_splits[i]:rt.row_splits[i+1]].

Пример:

print(tf.RaggedTensor.from_row_splits(
      values=[3, 1, 4, 1, 5, 9, 2, 6],
      row_splits=[0, 4, 4, 7, 8, 8]))
<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>

Альтернативные схемы разбиения строк

В дополнение к row_splits, разряженные тензоры поддерживают пять других схем разбиения строк:

• row_lengths: вектор с формой [nrows], который определяет длину каждой строки.

• value_rowids и nrows: value_rowids — вектор с формой [nvals], соответствующий один к одному с values, который определяет индекс строки для каждого значения. В частности, строка rt[row] состоит из значений rt.values[j], где value_rowids[j]==row. nrows — скалярное целое число, определяющее количество строк в RaggedTensor. (nrows используется для обозначения хвостовых пустых строк.)

• row_starts: вектор с формой [nrows], который определяет начальный смещение каждой строки. Эквивалентно row_splits[:-1].

• row_limits: вектор с формой [nrows], который определяет конечное смещение каждой строки. Эквивалентно row_splits[1:].

• uniform_row_length: скалярный тензор, определяющий длину каждой строки. Эта схема разбиения строк может быть использована только если все строки имеют одинаковую длину.

Пример: следующие разряженные тензоры эквивалентны и все представляют вложенный список [[3, 1, 4, 1], [], [5, 9, 2], [6], []].

values = [3, 1, 4, 1, 5, 9, 2, 6]
rt1 = RaggedTensor.from_row_splits(values, row_splits=[0, 4, 4, 7, 8, 8])
rt2 = RaggedTensor.from_row_lengths(values, row_lengths=[4, 0, 3, 1, 0])
rt3 = RaggedTensor.from_value_rowids(
    values, value_rowids=[0, 0, 0, 0, 2, 2, 2, 3], nrows=5)
rt4 = RaggedTensor.from_row_starts(values, row_starts=[0, 4, 4, 7, 8])
rt5 = RaggedTensor.from_row_limits(values, row_limits=[4, 4, 7, 8, 8])

Несколько разряженных измерений

Разряженные тензоры с несколькими разряженными измерениями могут быть определены, используя вложенный RaggedTensor для тензора values. Каждый вложенный RaggedTensor добавляет одно разряженное измерение.

inner_rt = RaggedTensor.from_row_splits(  # =rt1 from above
    values=[3, 1, 4, 1, 5, 9, 2, 6], row_splits=[0, 4, 4, 7, 8, 8])
outer_rt = RaggedTensor.from_row_splits(
    values=inner_rt, row_splits=[0, 3, 3, 5])
print(outer_rt.to_list())
[[[3, 1, 4, 1], [], [5, 9, 2]], [], [[6], []]]
print(outer_rt.ragged_rank)
2

Функция-фабрика RaggedTensor.from_nested_row_splits может быть использована для построения разряженного тензора с несколькими разряженными измерениями непосредственно, предоставив список тензоров row_splits.

RaggedTensor.from_nested_row_splits(
    flat_values=[3, 1, 4, 1, 5, 9, 2, 6],
    nested_row_splits=([0, 3, 3, 5], [0, 4, 4, 7, 8, 8])).to_list()
[[[3, 1, 4, 1], [], [5, 9, 2]], [], [[6], []]]

Однородные внутренние измерения

Разряженные тензоры с однородными внутренними измерениями могут быть определены, используя многомерный Tensor для values.

rt = RaggedTensor.from_row_splits(values=tf.ones([5, 3], tf.int32),
                                  row_splits=[0, 2, 5])
print(rt.to_list())
[[[1, 1, 1], [1, 1, 1]],
 [[1, 1, 1], [1, 1, 1], [1, 1, 1]]]
print(rt.shape)
(2, None, 3)

Однородные внешние измерения

Разряженные тензоры с однородными внешними измерениями могут быть определены, используя один или несколько RaggedTensor с тензором разбиения строк uniform_row_length. Например, разряженный тензор с формой [2, 2, None] может быть построен таким методом из тензора значений RaggedTensor с формой [4, None]:

values = tf.ragged.constant([[1, 2, 3], [4], [5, 6], [7, 8, 9, 10]])
print(values.shape)
(4, None)
rt6 = tf.RaggedTensor.from_uniform_row_length(values, 2)
print(rt6)
<tf.RaggedTensor [[[1, 2, 3], [4]], [[5, 6], [7, 8, 9, 10]]]>
print(rt6.shape)
(2, 2, None)

Обратите внимание, что rt6 содержит только одно разряженное измерение (самое внутреннее измерение). В отличие от этого, если from_row_splits используется для построения аналогичного RaggedTensor, то этот RaggedTensor будет иметь два разряженных измерения:

rt7 = tf.RaggedTensor.from_row_splits(values, [0, 2, 4])
print(rt7.shape)
(2, None, None)

Однородные и разряженные внешние измерения могут чередоваться, то есть может быть создан тензор с любой комбинацией разряженных и однородных измерений. Например, разряженный тензор t4 с формой [3, None, 4, 8, None, 2] можно построить следующим образом:

t0 = tf.zeros([1000, 2])                           # Shape:         [1000, 2]
t1 = RaggedTensor.from_row_lengths(t0, [...])      #           [160, None, 2]
t2 = RaggedTensor.from_uniform_row_length(t1, 8)   #         [20, 8, None, 2]
t3 = RaggedTensor.from_uniform_row_length(t2, 4)   #       [5, 4, 8, None, 2]
t4 = RaggedTensor.from_row_lengths(t3, [...])      # [3, None, 4, 8, None, 2]

rt = tf.ragged.constant([[[3, 1, 4, 1], [], [5, 9, 2]], [], [[6], []]])
print(rt.flat_values)
tf.Tensor([3 1 4 1 5 9 2 6], shape=(8,), dtype=int32)

rt = tf.ragged.constant(
    [[[[3, 1, 4, 1], [], [5, 9, 2]], [], [[6], []]]])
for i, splits in enumerate(rt.nested_row_splits):
  print('Splits for dimension %d: %s' % (i+1, splits.numpy()))
Splits for dimension 1: [0 3]
Splits for dimension 2: [0 3 3 5]
Splits for dimension 3: [0 4 4 7 8 8]

rt = tf.ragged.constant([[3, 1, 4, 1], [], [5, 9, 2], [6], []])
print(rt.row_splits)  # indices of row splits in rt.values
tf.Tensor([0 4 4 7 8 8], shape=(6,), dtype=int64)

tf.ragged.constant([[0], [1, 2]]).shape
TensorShape([2, None])

tf.ragged.constant([[[0, 1]], [[1, 2], [3, 4]]], ragged_rank=1).shape
TensorShape([2, None, 2])

rt1 = tf.ragged.constant([[1, 2, 3], [4], [5, 6], [7, 8, 9, 10]])
print(rt1.uniform_row_length)  # rows are ragged.
None

rt2 = tf.RaggedTensor.from_uniform_row_length(
    values=rt1, uniform_row_length=2)
print(rt2)
<tf.RaggedTensor [[[1, 2, 3], [4]], [[5, 6], [7, 8, 9, 10]]]>
print(rt2.uniform_row_length)  # rows are not ragged (all have size 2).
tf.Tensor(2, shape=(), dtype=int64)

rt = tf.ragged.constant([[3, 1, 4, 1], [], [5, 9, 2], [6], []])
print(rt.values)
tf.Tensor([3 1 4 1 5 9 2 6], shape=(8,), dtype=int32)

Методы

bounding_shape

Просмотреть исходный код

bounding_shape(
    axis=None, name=None, out_type=None
)

Возвращает форму ограничивающей рамки для этого RaggedTensor.

Пример:

rt = tf.ragged.constant([[1, 2, 3, 4], [5], [], [6, 7, 8, 9], [10]])
rt.bounding_shape().numpy()
array([5, 4])

consumers

Просмотреть исходный код

consumers()

from_nested_row_lengths

Просмотреть исходный код

@classmethod
from_nested_row_lengths(
    flat_values, nested_row_lengths, name=None, validate=True
)

Создаёт RaggedTensor из вложенного списка row_lengths тензоров.

Эквивалентно:

result = flat_values
for row_lengths in reversed(nested_row_lengths):
  result = from_row_lengths(result, row_lengths)

from_nested_row_splits

Просмотреть исходный код

@classmethod
from_nested_row_splits(
    flat_values, nested_row_splits, name=None, validate=True
)

Создаёт RaggedTensor из вложенного списка row_splits тензоров.

Эквивалентно:

result = flat_values
for row_splits in reversed(nested_row_splits):
  result = from_row_splits(result, row_splits)

from_nested_value_rowids

Просмотреть исходный код

@classmethod
from_nested_value_rowids(
    flat_values, nested_value_rowids, nested_nrows=None, name=None, validate=True
)

Создаёт RaggedTensor из вложенного списка value_rowids тензоров.

Эквивалентно:

result = flat_values
for (rowids, nrows) in reversed(zip(nested_value_rowids, nested_nrows)):
  result = from_value_rowids(result, rowids, nrows)

from_row_lengths

Просмотреть исходный код

@classmethod
from_row_lengths(
    values, row_lengths, name=None, validate=True
)

Создаёт RaggedTensor с рядами, разделяемыми row_lengths.

Возвращаемый RaggedTensor соответствует python списку, определённому:

result = [[values.pop(0) for i in range(length)]
          for length in row_lengths]

Пример:

print(tf.RaggedTensor.from_row_lengths(
    values=[3, 1, 4, 1, 5, 9, 2, 6],
    row_lengths=[4, 0, 3, 1, 0]))
<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>

from_row_limits

Просмотреть исходный код

@classmethod
from_row_limits(
    values, row_limits, name=None, validate=True
)

Создаёт RaggedTensor с рядами, разделяемыми row_limits.

Эквивалентно: from_row_splits(values, concat([0, row_limits])).

Пример:

print(tf.RaggedTensor.from_row_limits(
    values=[3, 1, 4, 1, 5, 9, 2, 6],
    row_limits=[4, 4, 7, 8, 8]))
<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>

from_row_splits

Просмотреть исходный код

@classmethod
from_row_splits(
    values, row_splits, name=None, validate=True
)

Создаёт RaggedTensor с рядами, разделяемыми row_splits.

Возвращаемый RaggedTensor соответствует python списку, определённому:

result = [values[row_splits[i]:row_splits[i + 1]]
          for i in range(len(row_splits) - 1)]

Пример:

print(tf.RaggedTensor.from_row_splits(
    values=[3, 1, 4, 1, 5, 9, 2, 6],
    row_splits=[0, 4, 4, 7, 8, 8]))
<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>

from_row_starts

Просмотреть исходный код

@classmethod
from_row_starts(
    values, row_starts, name=None, validate=True
)

Создаёт объект RaggedTensor с разбиением строк по row_starts.

Эквивалентно: from_row_splits(values, concat([row_starts, nvals])).

Пример:

print(tf.RaggedTensor.from_row_starts(
    values=[3, 1, 4, 1, 5, 9, 2, 6],
    row_starts=[0, 4, 4, 7, 8]))
<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>

from_sparse

Просмотреть исходный код

@classmethod
from_sparse(
    st_input, name=None, row_splits_dtype=tf.dtypes.int64
)

Преобразует 2D tf.sparse.SparseTensor в RaggedTensor.

Каждая строка output RaggedTensor будет содержать явные значения из той же строки в st_input. st_input должен быть нерегулярным справа. Если нет, то будет сгенерирована ошибка.

Пример:

indices = [[0, 0], [0, 1], [0, 2], [1, 0], [3, 0]]
st = tf.sparse.SparseTensor(indices=indices,
                            values=[1, 2, 3, 4, 5],
                            dense_shape=[4, 3])
tf.RaggedTensor.from_sparse(st).to_list()
[[1, 2, 3], [4], [], [5]]

В настоящее время поддерживаются только двумерные SparseTensors.

from_tensor

Просмотреть исходный код

@classmethod
from_tensor(
    tensor, lengths=None, padding=None, ragged_rank=1, name=None,
    row_splits_dtype=tf.dtypes.int64
)

Преобразует tf.Tensor в RaggedTensor.

Набор отсутствующих/по умолчанию значений может быть задан с помощью вектора длин или значения заполнения (но не обоих). Если lengths указано, то возвращаемый тензор будет удовлетворять output[row] = tensor[row][:lengths[row]]. Если `lengths` — список списков или кортеж списков, эти списки будут использованы как вложенные длины строк. Если padding указано, то любой суффикс строки, состоящий полностью из padding, будет исключён из возвращаемого RaggedTensor. Если ни lengths ни padding не указаны, то возвращаемый RaggedTensor не будет иметь отсутствующих/по умолчанию значений.

Примеры:

dt = tf.constant([[5, 7, 0], [0, 3, 0], [6, 0, 0]])
tf.RaggedTensor.from_tensor(dt)
<tf.RaggedTensor [[5, 7, 0], [0, 3, 0], [6, 0, 0]]>
tf.RaggedTensor.from_tensor(dt, lengths=[1, 0, 3])
<tf.RaggedTensor [[5], [], [6, 0, 0]]>

tf.RaggedTensor.from_tensor(dt, padding=0)
<tf.RaggedTensor [[5, 7], [0, 3], [6]]>

dt = tf.constant([[[5, 0], [7, 0], [0, 0]],
                  [[0, 0], [3, 0], [0, 0]],
                  [[6, 0], [0, 0], [0, 0]]])
tf.RaggedTensor.from_tensor(dt, lengths=([2, 0, 3], [1, 1, 2, 0, 1]))
<tf.RaggedTensor [[[5], [7]], [], [[6, 0], [], [0]]]>

from_uniform_row_length

Просмотреть исходный код

@classmethod
from_uniform_row_length(
    values, uniform_row_length, nrows=None, validate=True, name=None
)

Создаёт RaggedTensor с разбиением строк по uniform_row_length.

Этот метод может использоваться для создания RaggedTensor с несколькими равномерными внешними измерениями. Например, RaggedTensor с формой [2, 2, None] может быть сконструирован с помощью этого метода из RaggedTensor значений с формой [4, None]:

values = tf.ragged.constant([[1, 2, 3], [4], [5, 6], [7, 8, 9, 10]])
print(values.shape)
(4, None)
rt1 = tf.RaggedTensor.from_uniform_row_length(values, 2)
print(rt1)
<tf.RaggedTensor [[[1, 2, 3], [4]], [[5, 6], [7, 8, 9, 10]]]>
print(rt1.shape)
(2, 2, None)

Обратите внимание, что rt1 содержит только одно нерегулярное измерение (самое внутреннее измерение). В отличие от этого, если from_row_splits используется для построения аналогичного RaggedTensor, то этот RaggedTensor будет иметь два нерегулярных измерения:

rt2 = tf.RaggedTensor.from_row_splits(values, [0, 2, 4])
print(rt2.shape)
(2, None, None)

result = [[values.pop(0) for i in range(uniform_row_length)]
for _ in range(nrows)]

from_value_rowids

Просмотреть исходный код

@classmethod
from_value_rowids(
    values, value_rowids, nrows=None, name=None, validate=True
)

Создаёт RaggedTensor с разбиением строк по value_rowids.

Возвращаемый RaggedTensor соответствует определённому python списку:

result = [[values[i] for i in range(len(values)) if value_rowids[i] == row]
          for row in range(nrows)]

Пример:

print(tf.RaggedTensor.from_value_rowids(
    values=[3, 1, 4, 1, 5, 9, 2, 6],
    value_rowids=[0, 0, 0, 0, 2, 2, 2, 3],
    nrows=5))
<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>

merge_dims

Просмотр исходного кода

merge_dims(
    outer_axis, inner_axis
)

Объединяет внешние...внутренние оси в одну размерность.

Возвращает копию этого RaggedTensor со сжатым указанным диапазоном размерностей в одну размерность, с элементами в порядке строк.

Примеры:

rt = tf.ragged.constant([[[1, 2], [3]], [[4, 5, 6]]])
print(rt.merge_dims(0, 1))
<tf.RaggedTensor [[1, 2], [3], [4, 5, 6]]>
print(rt.merge_dims(1, 2))
<tf.RaggedTensor [[1, 2, 3], [4, 5, 6]]>
print(rt.merge_dims(0, 2))
tf.Tensor([1 2 3 4 5 6], shape=(6,), dtype=int32)

Чтобы имитировать поведение np.flatten (которое сжимает все размерности), используйте rt.merge_dims(0, -1). To mimic the behavior oftf.layers.Flatten(which flattens all dimensions except the outermost batch dimension), usert.merge_dims(1, -1)`.

nested_row_lengths

Просмотр исходного кода

nested_row_lengths(
    name=None
)

Возвращает кортеж, содержащий row_lengths для всех разряженных размерностей.

rt.nested_row_lengths() - кортеж, содержащий row_lengths тензоры для всех разряженных размерностей в rt, упорядоченные от внешней к внутренней.

nested_value_rowids

Просмотр исходного кода

nested_value_rowids(
    name=None
)

Возвращает кортеж, содержащий value_rowids для всех разряженных размерностей.

rt.nested_value_rowids - кортеж, содержащий value_rowids тензоры для всех разряженных размерностей в rt, упорядоченные от внешней к внутренней. В частности, rt.nested_value_rowids = (rt.value_rowids(),) + value_ids где:

* `value_ids = ()` if `rt.values` is a `Tensor`.
* `value_ids = rt.values.nested_value_rowids` otherwise.

Пример:

rt = tf.ragged.constant(
    [[[[3, 1, 4, 1], [], [5, 9, 2]], [], [[6], []]]])
for i, ids in enumerate(rt.nested_value_rowids()):
  print('row ids for dimension %d: %s' % (i+1, ids.numpy()))
row ids for dimension 1: [0 0 0]
row ids for dimension 2: [0 0 0 2 2]
row ids for dimension 3: [0 0 0 0 2 2 2 3]

nrows

Просмотр исходного кода

nrows(
    out_type=None, name=None
)

Возвращает количество строк в этом разряженном тензоре.

То есть размер внешней размерности тензора.

Пример:

rt = tf.ragged.constant([[3, 1, 4, 1], [], [5, 9, 2], [6], []])
print(rt.nrows())  # rt has 5 rows.
tf.Tensor(5, shape=(), dtype=int64)

numpy

Просмотр исходного кода

numpy()

Возвращает numpy array со значениями для этого RaggedTensor.

Требует, чтобы этот RaggedTensor был создан в режиме выполнения eager.

Разряженные размерности кодируются с помощью numpy arrays с dtype=object и rank=1, где каждый элемент - это одна строка.

Примеры

В следующем примере значение, возвращаемое RaggedTensor.numpy(), содержит три объекта numpy array: по одному для каждой строки (со rank=1 и dtype=int64), и один для их объединения (со rank=1 и dtype=object):

tf.ragged.constant([[1, 2, 3], [4, 5]], dtype=tf.int64).numpy()
array([array([1, 2, 3]), array([4, 5])], dtype=object)

Однородные размерности кодируются с помощью многомерных numpy arrays. В следующем примере значение, возвращаемое RaggedTensor.numpy(), содержит один объект numpy array с rank=2 и dtype=int64:

tf.ragged.constant([[1, 2, 3], [4, 5, 6]], dtype=tf.int64).numpy()
array([[1, 2, 3], [4, 5, 6]])

row_lengths

Просмотр исходного кода

row_lengths(
    axis=1, name=None
)

Возвращает длины строк в этом разряженном тензоре.

rt.row_lengths()[i] указывает число значений в i-й строке rt.

Пример:

rt = tf.ragged.constant(
    [[[3, 1, 4], [1]], [], [[5, 9], [2]], [[6]], []])
print(rt.row_lengths())  # lengths of rows in rt
tf.Tensor([2 0 2 1 0], shape=(5,), dtype=int64)
print(rt.row_lengths(axis=2))  # lengths of axis=2 rows.
<tf.RaggedTensor [[3, 1], [], [2, 1], [1], []]>

row_limits

Просмотр исходного кода

row_limits(
    name=None
)

Возвращает предельные индексы для строк в этом разряженном тензоре.

Эти индексы указывают, где заканчиваются значения для каждой строки в self.values. rt.row_limits(self) равно rt.row_splits[:-1].

Пример:

rt = tf.ragged.constant([[3, 1, 4, 1], [], [5, 9, 2], [6], []])
print(rt.values)
tf.Tensor([3 1 4 1 5 9 2 6], shape=(8,), dtype=int32)
print(rt.row_limits())  # indices of row limits in rt.values
tf.Tensor([4 4 7 8 8], shape=(5,), dtype=int64)

row_starts

Просмотр исходного кода

row_starts(
    name=None
)

Возвращает начальные индексы для строк в этом разряженном тензоре.

Эти индексы указывают, где начинаются значения для каждой строки в self.values. rt.row_starts() равно rt.row_splits[:-1].

Пример:

rt = tf.ragged.constant([[3, 1, 4, 1], [], [5, 9, 2], [6], []])
print(rt.values)
tf.Tensor([3 1 4 1 5 9 2 6], shape=(8,), dtype=int32)
print(rt.row_starts())  # indices of row starts in rt.values
tf.Tensor([0 4 4 7 8], shape=(5,), dtype=int64)

to_list

Просмотреть исходный код

to_list()

Возвращает вложенный Python list со значениями для этого RaggedTensor.

Требуется, чтобы rt был построен в режиме выполнения Eager.

to_sparse

Просмотреть исходный код

to_sparse(
    name=None
)

Преобразует этот RaggedTensor в tf.sparse.SparseTensor.

Пример:

rt = tf.ragged.constant([[1, 2, 3], [4], [], [5, 6]])
print(rt.to_sparse())
SparseTensor(indices=tf.Tensor(
                 [[0 0] [0 1] [0 2] [1 0] [3 0] [3 1]],
                 shape=(6, 2), dtype=int64),
             values=tf.Tensor([1 2 3 4 5 6], shape=(6,), dtype=int32),
             dense_shape=tf.Tensor([4 3], shape=(2,), dtype=int64))

to_tensor

Просмотреть исходный код

to_tensor(
    default_value=None, name=None, shape=None
)

Преобразует этот RaggedTensor в tf.Tensor.

Если shape указан, результат дополняется и/или усекается до указанной формы.

Примеры:

rt = tf.ragged.constant([[9, 8, 7], [], [6, 5], [4]])
print(rt.to_tensor())
tf.Tensor(
    [[9 8 7] [0 0 0] [6 5 0] [4 0 0]], shape=(4, 3), dtype=int32)
print(rt.to_tensor(shape=[5, 2]))
tf.Tensor(
    [[9 8] [0 0] [6 5] [4 0] [0 0]], shape=(5, 2), dtype=int32)

value_rowids

Просмотреть исходный код

value_rowids(
    name=None
)

Возвращает индексы строк для values в этом разряженном тензоре.

rt.value_rowids() соответствует попарно внешнему измерению rt.values, и указывает строку, содержащую каждое значение. В частности, строка rt[row] состоит из значений rt.values[j], где rt.value_rowids()[j] == row.

Пример:

rt = tf.ragged.constant([[3, 1, 4, 1], [], [5, 9, 2], [6], []])
print(rt.values)
tf.Tensor([3 1 4 1 5 9 2 6], shape=(8,), dtype=int32)
print(rt.value_rowids())  # corresponds 1:1 with rt.values
tf.Tensor([0 0 0 0 2 2 2 3], shape=(8,), dtype=int64)

with_flat_values

Просмотреть исходный код

with_flat_values(
    new_values
)

Возвращает копию self со значениями flat_values заменены на new_value.

Сохраняет кэшированные тензоры разбиения строк, такие как self.cached_nrows и self.cached_value_rowids, если они имеют значения.

with_row_splits_dtype

Просмотреть исходный код

with_row_splits_dtype(
    dtype
)

Возвращает копию этого разряженного тензора с заданным типом row_splits.

Для разряженных тензоров с несколькими разряженными измерениями row_splits для всех вложенных RaggedTensor объектов преобразуются к указанному типу.

with_values

Просмотреть исходный код

with_values(
    new_values
)

Возвращает копию self со значениями values замененными на new_value.

Сохраняет кэшированные тензоры разбиения строк, такие как self.cached_nrows и self.cached_value_rowids если они содержат значения.

__abs__

Просмотреть исходный код

__abs__(
    x, name=None
)

Вычисляет абсолютное значение тензора.

Для тензора со значениями целых чисел или с плавающей точкой эта операция возвращает тензор того же типа, где каждый элемент содержит абсолютное значение соответствующего элемента на входе.

Для тензора x комплексных чисел эта операция возвращает тензор типа float32 или float64, который представляет собой абсолютное значение каждого элемента в x. Для комплексного числа \(a + bj\), его абсолютное значение вычисляется как \(\sqrt{a^2

• b^2}\). Например:

x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])
tf.abs(x)
<tf.Tensor: shape=(2, 1), dtype=float64, numpy=
array([[5.25594901],
       [6.60492241]])>

__add__

__add__(
    x, y, name=None
)

Возвращает x + y поэлементно.

Примечание: math.add поддерживает трансляцию. AddN не поддерживает. Подробнее о трансляции здесь

__and__

View source

__and__(
    x, y, name=None
)

Логическая функция И.

Операция работает для следующих типов входных данных:

• Два отдельных элемента типа bool
• Один tf.Tensor типа bool и один отдельный bool, где результат вычисляется путём применения логического И с отдельным элементом ко каждому элементу в более крупном тензоре.
• Два tf.Tensor объекта типа bool одной и той же формы. В этом случае результат будет являться поэлементным логическим И двух входных тензоров.

Использование:

a = tf.constant([True])
b = tf.constant([False])
tf.math.logical_and(a, b)
<tf.Tensor: shape=(1,), dtype=bool, numpy=array([False])>

c = tf.constant([True])
x = tf.constant([False, True, True, False])
tf.math.logical_and(c, x)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False,  True,  True, False])>

y = tf.constant([False, False, True, True])
z = tf.constant([False, True, False, True])
tf.math.logical_and(y, z)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False, False, False,  True])>

__bool__

View source

__bool__(
    _
)

Метод-заглушка, чтобы предотвратить использование RaggedTensor в качестве Python bool.

__div__

View source

__div__(
    x, y, name=None
)

Деление x / y поэлементно (используя семантику оператора деления Python 2). (устаревшее)

Примечание: Предпочтительнее использовать оператор деления тензоров или tf.divide, которые подчиняются семантике оператора деления Python 3.

Эта функция делит x и y, принуждая к семантике Python 2. То есть, если x и y — оба целые числа, то результат будет целым числом. Это отличается от Python 3, где деление с / всегда является числом с плавающей точкой, а деление с // всегда является целым числом.

__floordiv__

View source

__floordiv__(
    x, y, name=None
)

Делит x / y поэлементно, округляя в сторону наименее положительного целого числа.

То же самое, что и tf.compat.v1.div(x,y) для целых чисел, но использует tf.floor(tf.compat.v1.div(x,y)) для аргументов с плавающей точкой, чтобы результат всегда был целым числом (хотя, возможно, целым числом, представленным в формате с плавающей точкой). Эта операция генерируется операцией целочисленного деления с округлением вниз в Python 3 и в Python 2.7 с from __future__ import division.

x и y должны иметь одинаковый тип, и результат также будет иметь тот же тип.

__ge__

__ge__(
    x, y, name=None
)

Возвращает логическое значение (x >= y) поэлементно.

Примечание: math.greater_equal поддерживает векторизацию. Дополнительную информацию о векторизации см. здесь

Пример:

x = tf.constant([5, 4, 6, 7])
y = tf.constant([5, 2, 5, 10])
tf.math.greater_equal(x, y) ==> [True, True, True, False]

x = tf.constant([5, 4, 6, 7])
y = tf.constant([5])
tf.math.greater_equal(x, y) ==> [True, False, True, True]

__getitem__

View source

__getitem__(
    key
)

Возвращает указанный фрагмент этого RaggedTensor.

Поддерживает многомерную индексацию и срезку, с одним ограничением: индексирование по фрагментированному внутреннему измерению запрещено. Этот случай проблематичен, потому что указанное значение может существовать в некоторых строках, но не в других. В таких случаях неясно, следует ли (1) сообщать об ошибке IndexError; (2) использовать значение по умолчанию; или (3) пропустить это значение и вернуть тензор с меньшим количеством строк, чем у нас было вначале. Следуя руководящим принципам Python («В случае неоднозначности откажитесь от искушения угадывать»), мы просто запрещаем эту операцию.

Примеры:

# A 2-D ragged tensor with 1 ragged dimension.
rt = tf.ragged.constant([['a', 'b', 'c'], ['d', 'e'], ['f'], ['g']])
rt[0].numpy()                 # First row (1-D `Tensor`)
array([b'a', b'b', b'c'], dtype=object)
rt[:3].to_list()              # First three rows (2-D RaggedTensor)
[[b'a', b'b', b'c'], [b'd', b'e'], [b'f']]
rt[3, 0].numpy()              # 1st element of 4th row (scalar)
b'g'

# A 3-D ragged tensor with 2 ragged dimensions.
rt = tf.ragged.constant([[[1, 2, 3], [4]],
                         [[5], [], [6]],
                         [[7]],
                         [[8, 9], [10]]])
rt[1].to_list()               # Second row (2-D RaggedTensor)
[[5], [], [6]]
rt[3, 0].numpy()              # First element of fourth row (1-D Tensor)
array([8, 9], dtype=int32)
rt[:, 1:3].to_list()          # Items 1-3 of each row (3-D RaggedTensor)
[[[4]], [[], [6]], [], [[10]]]
rt[:, -1:].to_list()          # Last item of each row (3-D RaggedTensor)
[[[4]], [[6]], [[7]], [[10]]]

__gt__

__gt__(
    x, y, name=None
)

Возвращает логическое значение (x > y) поэлементно.

Примечание: math.greater поддерживает векторизацию. Дополнительную информацию о векторизации см. здесь

Пример:

x = tf.constant([5, 4, 6])
y = tf.constant([5, 2, 5])
tf.math.greater(x, y) ==> [False, True, True]

x = tf.constant([5, 4, 6])
y = tf.constant([5])
tf.math.greater(x, y) ==> [False, False, True]

__invert__

__invert__(
    x, name=None
)

Возвращает логическое значение элемента NOT x.

Пример:

tf.math.logical_not(tf.constant([True, False]))
<tf.Tensor: shape=(2,), dtype=bool, numpy=array([False,  True])>

__le__

__le__(
    x, y, name=None
)

Возвращает логическое значение (x <= y) поэлементно.

Примечание: math.less_equal поддерживает широковещательную передачу. Подробнее о широковещательной передаче здесь

Пример:

x = tf.constant([5, 4, 6])
y = tf.constant([5])
tf.math.less_equal(x, y) ==> [True, True, False]

x = tf.constant([5, 4, 6])
y = tf.constant([5, 6, 6])
tf.math.less_equal(x, y) ==> [True, True, True]

__lt__

__lt__(
    x, y, name=None
)

Возвращает логическое значение (x < y) поэлементно.

Примечание: math.less поддерживает широковещательную передачу. Подробнее о широковещательной передаче здесь

Пример:

x = tf.constant([5, 4, 6])
y = tf.constant([5])
tf.math.less(x, y) ==> [False, True, False]

x = tf.constant([5, 4, 6])
y = tf.constant([5, 6, 7])
tf.math.less(x, y) ==> [False, True, True]

__mod__

__mod__(
    x, y, name=None
)

Возвращает остаток от деления поэлементно. Когда x < 0 xor y < 0 является

истинным, это соответствует семантике Python, в том, что результат здесь согласуется с делением с округлением вниз. Например, floor(x / y) * y + mod(x, y) = x.

Примечание: math.floormod поддерживает широковещательную передачу. Подробнее о широковещательной передаче здесь

__mul__

Посмотреть исходный код

__mul__(
    x, y, name=None
)

Возвращает поэлементное x * y.

Например:

x = tf.constant(([1, 2, 3, 4]))
tf.math.multiply(x, x)
<tf.Tensor: shape=(4,), dtype=..., numpy=array([ 1,  4,  9, 16], dtype=int32)>

Поскольку tf.math.multiply преобразует свои аргументы в Tensorы, вы также можете передавать не-Tensor аргументы:

tf.math.multiply(7,6)
<tf.Tensor: shape=(), dtype=int32, numpy=42>

Если x.shape не совпадает с y.shape, они будут приведены к совместимой форме. (Подробнее о широковещательной передаче здесь.)

Например:

x = tf.ones([1, 2]);
y = tf.ones([2, 1]);
x * y  # Taking advantage of operator overriding
<tf.Tensor: shape=(2, 2), dtype=float32, numpy=
array([[1., 1.],
     [1., 1.]], dtype=float32)>

A Tensor. Имеет тот же тип, что и x.

__neg__

__neg__(
    x, name=None
)

Вычисляет поэлементное отрицательное значение.

Т.е., \(y = -x\).

__nonzero__

Посмотреть исходный код

__nonzero__(
    _
)

Метод-заглушка, чтобы предотвратить использование RaggedTensor как Python bool.

__or__

__or__(
    x, y, name=None
)

Возвращает логическое значение x OR y поэлементно.

Примечание: math.logical_or поддерживает широковещательную передачу. Подробнее о широковещательной передаче здесь

__pow__

Просмотр исходного кода

__pow__(
    x, y, name=None
)

Вычисляет степень одного значения по другому.

Учитывая тензор x и тензор y, эта операция вычисляет \(x^y\) для соответствующих элементов в x и y. Например:

x = tf.constant([[2, 2], [3, 3]])
y = tf.constant([[8, 16], [2, 3]])
tf.pow(x, y)  # [[256, 65536], [9, 27]]

__radd__

__radd__(
    x, y, name=None
)

Возвращает x + y поэлементно.

Примечание: math.add поддерживает векторизацию. AddN не поддерживает. Подробнее о векторизации здесь

__rand__

Просмотр исходного кода

__rand__(
    x, y, name=None
)

Логическая операция И.

Операция работает для следующих типов входных данных:

• Два отдельных элемента типа bool
• Один tf.Tensor типа bool и один отдельный bool, где результат будет рассчитан путем применения логического И с одиночным элементом к каждому элементу в большем тензоре.
• Два tf.Tensor объекта типа bool одинаковой формы. В этом случае результатом будет поэлементное логическое И двух входных тензоров.

Использование:

a = tf.constant([True])
b = tf.constant([False])
tf.math.logical_and(a, b)
<tf.Tensor: shape=(1,), dtype=bool, numpy=array([False])>

c = tf.constant([True])
x = tf.constant([False, True, True, False])
tf.math.logical_and(c, x)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False,  True,  True, False])>

y = tf.constant([False, False, True, True])
z = tf.constant([False, True, False, True])
tf.math.logical_and(y, z)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False, False, False,  True])>

__rdiv__

Просмотр исходного кода

__rdiv__(
    x, y, name=None
)

Делит x / y поэлементно (используя семантику оператора деления Python 2). (устарело)

Примечание: Предпочтительнее использовать оператор деления тензоров или tf.divide, которые следуют семантике оператора деления Python 3.

Эта функция делит x и y, принуждая к семантике Python 2. То есть, если x и y — оба целые числа, то результат будет целым числом. Это в отличие от Python 3, где деление с / всегда является числом с плавающей точкой, а деление с // всегда является целым числом.

__rfloordiv__

Просмотр исходного кода

__rfloordiv__(
    x, y, name=None
)

Делит x / y поэлементно, округляя к ближайшему меньшему целому.

То же, что и tf.compat.v1.div(x,y) для целых чисел, но использует tf.floor(tf.compat.v1.div(x,y)) для аргументов с плавающей запятой, так что результат всегда является целым числом (возможно, целым числом, представленным с плавающей запятой). Эта операция генерируется операцией целочисленного деления с округлением вниз в Python 3 и в Python 2.7 с from __future__ import division.

x и y должны иметь одинаковый тип, и результат также будет иметь тот же тип.

__rmod__

__rmod__(
    x, y, name=None
)

Возвращает поэлементный остаток от деления. Когда x < 0 или y < 0

истинно, это следует семантике Python, в том, что результат здесь согласуется с делением с округлением к ближайшему меньшему целому. Например: floor(x / y) * y + mod(x, y) = x.

Примечание: math.floormod поддерживает векторизацию. Подробнее о векторизации здесь

__rmul__

Просмотр исходного кода

__rmul__(
    x, y, name=None
)

Возвращает поэлементное x * y.

Например:

x = tf.constant(([1, 2, 3, 4]))
tf.math.multiply(x, x)
<tf.Tensor: shape=(4,), dtype=..., numpy=array([ 1,  4,  9, 16], dtype=int32)>

Так как tf.math.multiply преобразует свои аргументы в Tensors, вы также можете передавать не-Tensor аргументы:

tf.math.multiply(7,6)
<tf.Tensor: shape=(), dtype=int32, numpy=42>

Если x.shape не совпадает с y.shape, они будут преобразованы к совместимой форме. (Подробнее о векторизации здесь.)

Например:

x = tf.ones([1, 2]);
y = tf.ones([2, 1]);
x * y  # Taking advantage of operator overriding
<tf.Tensor: shape=(2, 2), dtype=float32, numpy=
array([[1., 1.],
     [1., 1.]], dtype=float32)>

A Tensor. Имеет тот же тип, что и x.

__ror__

__ror__(
    x, y, name=None
)

Возвращает истинностное значение x ИЛИ y поэлементно.

Примечание: math.logical_or поддерживает векторизацию. Подробнее о векторизации здесь

__rpow__

Просмотреть исходный код

__rpow__(
    x, y, name=None
)

Вычисляет степень одного значения относительно другого.

Даны тензоры x и y, эта операция вычисляет \(x^y\) для соответствующих элементов в x и y. Например:

x = tf.constant([[2, 2], [3, 3]])
y = tf.constant([[8, 16], [2, 3]])
tf.pow(x, y)  # [[256, 65536], [9, 27]]

__rsub__

Просмотреть исходный код

__rsub__(
    x, y, name=None
)

Возвращает x - y поэлементно.

Примечание: Subtract поддерживает векторизацию. Подробнее о векторизации здесь

__rtruediv__

Просмотреть исходный код

__rtruediv__(
    x, y, name=None
)

Делит x / y поэлементно (используя семантику оператора деления Python 3).

Примечание: Предпочтительнее использовать оператор тензора или tf.divide, которые подчиняются семантике оператора деления Python.

Эта функция принудительно использует семантику оператора деления Python 3, где все целочисленные аргументы сначала преобразуются в плавающие типы. Эта операция генерируется обычным оператором x / y деления в Python 3 и в Python 2.7 с from __future__ import division. Если вам нужна целочисленная операция деления с округлением вниз, используйте x // y или tf.math.floordiv.

x и y должны иметь тот же числовой тип. Если входные данные являются числами с плавающей точкой, выходной тип будет таким же. Если входные данные являются целыми числами, они преобразуются в тип float32 для int8 и int16 и float64 для int32 и int64 (соответствуя поведению Numpy).

__rxor__

Просмотреть исходный код

__rxor__(
    x, y, name='LogicalXor'
)

Логическая операция XOR.

x ^ y = (x | y) & ~(x & y)

Операция работает со следующими типами входных данных:

• Два отдельных элемента типа bool
• Один tf.Tensor типа bool и один отдельный bool, где результат вычисляется путём применения логического XOR к отдельному элементу и каждому элементу в большем тензоре.
• Два объекта tf.Tensor типа bool с одинаковой формой. В этом случае результатом будет поэлементное логическое XOR двух входных тензоров.

Использование:

a = tf.constant([True])
b = tf.constant([False])
tf.math.logical_xor(a, b)
<tf.Tensor: shape=(1,), dtype=bool, numpy=array([ True])>

c = tf.constant([True])
x = tf.constant([False, True, True, False])
tf.math.logical_xor(c, x)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([ True, False, False,  True])>

y = tf.constant([False, False, True, True])
z = tf.constant([False, True, False, True])
tf.math.logical_xor(y, z)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False,  True,  True, False])>

__sub__

Просмотреть исходный код

__sub__(
    x, y, name=None
)

Возвращает x - y поэлементно.

Примечание: Subtract поддерживает векторизацию. Подробнее о векторизации здесь

__truediv__

Просмотреть исходный код

__truediv__(
    x, y, name=None
)

Делит x / y поэлементно (используя семантику оператора деления Python 3).

Примечание: Предпочтительнее использовать оператор тензора или tf.divide, которые подчиняются семантике оператора деления Python.

Эта функция принудительно использует семантику оператора деления Python 3, где все целочисленные аргументы сначала преобразуются в плавающие типы. Эта операция генерируется обычным оператором x / y деления в Python 3 и в Python 2.7 с from __future__ import division. Если вам нужна целочисленная операция деления с округлением вниз, используйте x // y или tf.math.floordiv.

x и y должны иметь одинаковый числовой тип. Если входные данные — числа с плавающей точкой, то выход будет иметь тот же тип. Если входные данные — целые числа, входные данные преобразуются в float32 для int8 и int16 и float64 для int32 и int64 (соответствуя поведению Numpy).

__xor__

Посмотреть исходный код

__xor__(
    x, y, name='LogicalXor'
)

Функция логического XOR.

x ^ y = (x | y) & ~(x & y)

Операция работает для следующих типов входных данных:

• Два одиночных элемента типа bool
• Один tf.Tensor типа bool и один одиночный bool, где результат будет вычислен путём применения логического XOR с одиночным элементом к каждому элементу в более крупном тензоре.
• Два tf.Tensor объекта типа bool одинаковой формы. В этом случае результатом будет поэлементный логический XOR двух входных тензоров.

Использование:

a = tf.constant([True])
b = tf.constant([False])
tf.math.logical_xor(a, b)
<tf.Tensor: shape=(1,), dtype=bool, numpy=array([ True])>

c = tf.constant([True])
x = tf.constant([False, True, True, False])
tf.math.logical_xor(c, x)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([ True, False, False,  True])>

y = tf.constant([False, False, True, True])
z = tf.constant([False, True, False, True])
tf.math.logical_xor(y, z)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False,  True,  True, False])>