tf.RaggedTensor

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

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

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

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

* <a href="../tf/RaggedTensor#from_row_lengths"><code>tf.RaggedTensor.from_row_lengths</code></a>
* <a href="../tf/RaggedTensor#from_value_rowids"><code>tf.RaggedTensor.from_value_rowids</code></a>
* <a href="../tf/RaggedTensor#from_row_splits"><code>tf.RaggedTensor.from_row_splits</code></a>
* <a href="../tf/RaggedTensor#from_row_starts"><code>tf.RaggedTensor.from_row_starts</code></a>
* <a href="../tf/RaggedTensor#from_row_limits"><code>tf.RaggedTensor.from_row_limits</code></a>
* <a href="../tf/RaggedTensor#from_nested_row_splits"><code>tf.RaggedTensor.from_nested_row_splits</code></a>
* <a href="../tf/RaggedTensor#from_nested_row_lengths"><code>tf.RaggedTensor.from_nested_row_lengths</code></a>
* <a href="../tf/RaggedTensor#from_nested_value_rowids"><code>tf.RaggedTensor.from_nested_value_rowids</code></a>

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

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

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

При документировании формы разряженного тензора разряженные измерения можно указывать, заключая их в скобки. Например, форма трехмерного разряженного тензора, хранящего вложенный вектор слов фиксированной длины для каждого слова в предложении, для каждого предложения в пакете, может быть записана как [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, этот разряженный тензор будет иметь два разряженных измерения:

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]

values = tf.ragged.constant([[1, 2, 3], [4], [5, 6], [7, 8, 9, 10]])
values.ragged_rank
1

rt = tf.RaggedTensor.from_uniform_row_length(values, 2)
rt.ragged_rank
2

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()

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
)

Преобразует двумерный 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 соответствует определённому в питоне списку:

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], []]>

get_shape

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

get_shape()

Статически известная форма этого разряженного тензора.

Псевдоним для свойства shape.

Примеры:

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

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

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 со значениями для этого разряженного тензора.

Требуется, чтобы этот разряженный тензор был создан в режиме выполнения 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 array. В следующем примере значение, возвращаемое 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 список со значениями для этого разряженного тензора.

Требуется, чтобы этот разряженный тензор был создан в режиме выполнения 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
)

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

Для RaggedTensor с несколькими разряженными измерениями, 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}\).

Например:

# real number
x = tf.constant([-2.25, 3.25])
tf.abs(x)
<tf.Tensor: shape=(2,), dtype=float32,
numpy=array([2.25, 3.25], dtype=float32)>

# complex number
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 не поддерживает. Подробнее о вещании здесь

Для двух входных тензоров операция tf.add вычисляет сумму для каждого элемента в тензоре.

И входные, и выходные данные имеют диапазон (-inf, inf).

__and__

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

__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__

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

__bool__(
    _
)

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

__div__

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

__div__(
    x, y, name=None
)

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

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

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

__eq__

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

__eq__(
    other
)

Операция, вызываемая оператором Tensor.eq.

Сравнивает два тензора по элементам на равенство, если они совместимы по векторизации; или возвращает False, если они не совместимы по векторизации. (Обратите внимание, что это поведение отличается от tf.math.equal, который генерирует исключение, если два тензора не совместимы по векторизации.)

Цель в API:

Этот метод представлен в API TensorFlow, чтобы разработчики библиотек могли регистрировать диспетчеризацию для Tensor.eq, чтобы позволить ей обрабатывать пользовательские составные тензоры и другие пользовательские объекты.

Символ API не предназначен для прямого вызова пользователями и отображается в сгенерированной документации TensorFlow.

__floordiv__

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

__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__

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

__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.

__ne__

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

__ne__(
    other
)

Операция, вызываемая оператором Tensor.ne.

Сравнивает два тензора поэлементно на неравенство, если они совместимы для вещания; или возвращает True, если они не совместимы для вещания. (Обратите внимание, что это поведение отличается от tf.math.not_equal, которое вызывает исключение, если два тензора не совместимы для вещания.)

Назначение в API:

Этот метод представлен в API TensorFlow, чтобы разработчики библиотек могли зарегистрировать диспетчеризацию для Tensor.ne, чтобы разрешить ему обрабатывать пользовательские составные тензоры и другие пользовательские объекты.

Символ API не предназначен для прямого вызова пользователями и появляется в сгенерированной документации TensorFlow.

__neg__

__neg__(
    x, name=None
)

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

То есть \(y = -x\).

__nonzero__

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

__nonzero__(
    _
)

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

__or__

__or__(
    x, y, name=None
)

Возвращает логическое значение x ИЛИ 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 нет. Подробнее о векторизации здесь

Для двух входных тензоров операция tf.add вычисляет сумму для каждого элемента в тензоре.

Входные и выходные значения имеют диапазон (-inf, inf).

__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 xor 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 преобразует свои аргументы в 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.

__ror__

__ror__(
    x, y, name=None
)

Возвращает логическое значение x OR 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).

Примечание: Предпочтительнее использовать оператор Tensor или 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])>