tf.RaggedTensor

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

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

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

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

• tf.RaggedTensor.from_row_lengths
• tf.RaggedTensor.from_value_rowids
• tf.RaggedTensor.from_row_splits
• tf.RaggedTensor.from_row_starts
• tf.RaggedTensor.from_row_limits
• tf.RaggedTensor.from_nested_row_splits
• tf.RaggedTensor.from_nested_row_lengths
• tf.RaggedTensor.from_nested_value_rowids

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

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

Документирование форм 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]
RaggedTensor.from_row_splits(values, row_splits=[0, 4, 4, 7, 8, 8])
<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>
RaggedTensor.from_row_lengths(values, row_lengths=[4, 0, 3, 1, 0])
<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>
RaggedTensor.from_value_rowids(
    values, value_rowids=[0, 0, 0, 0, 2, 2, 2, 3], nrows=5)
<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>
RaggedTensor.from_row_starts(values, row_starts=[0, 4, 4, 7, 8])
<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>
RaggedTensor.from_row_limits(values, row_limits=[4, 4, 7, 8, 8])
<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>
RaggedTensor.from_uniform_row_length(values, uniform_row_length=2)
<tf.RaggedTensor [[3, 1], [4, 1], [5, 9], [2, 6]]>

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

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

* `value_splits = ()` if `rt.values` is a `Tensor`.
* `value_splits = rt.values.nested_row_splits` otherwise.

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
)

Возвращает форму границ для этого разряженного тензора.

Пример:

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 в output.

Каждая строка 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], []]>

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
)

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

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 = () если rt.values является Tensor.
• value_ids = rt.values.nested_value_rowids в противном случае.

Пример:

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 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 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__(
    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__(
    y, name=None
)

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

Примеры использования ниже.

Сложение скаляра и списка:

x = [1, 2, 3, 4, 5]
y = 1
tf.add(x, y)
<tf.Tensor: shape=(5,), dtype=int32, numpy=array([2, 3, 4, 5, 6],
dtype=int32)>

Обратите внимание, что бинарный + оператор может быть использован вместо этого:

x = tf.convert_to_tensor([1, 2, 3, 4, 5])
y = tf.convert_to_tensor(1)
x + y
<tf.Tensor: shape=(5,), dtype=int32, numpy=array([2, 3, 4, 5, 6],
dtype=int32)>

Сложение тензора и списка той же формы:

x = [1, 2, 3, 4, 5]
y = tf.constant([1, 2, 3, 4, 5])
tf.add(x, y)
<tf.Tensor: shape=(5,), dtype=int32,
numpy=array([ 2,  4,  6,  8, 10], dtype=int32)>

Например,

x = tf.constant([1, 2], dtype=tf.int8)
y = [2**7 + 1, 2**7 + 2]
tf.add(x, y)
<tf.Tensor: shape=(2,), dtype=int8, numpy=array([-126, -124], dtype=int8)>

При сложении двух входных значений с различными формами, Add следует правилам векторизации NumPy. Формы двух входных массивов сравниваются поэлементно. Начиная с последних измерений, два измерения либо должны быть равны, либо одно из них должно быть 1.

Например,

x = np.ones(6).reshape(1, 2, 1, 3)
y = np.ones(6).reshape(2, 1, 3, 1)
tf.add(x, y).shape.as_list()
[2, 2, 3, 3]

Еще один пример со двумя массивами с различными измерениями.

x = np.ones([1, 2, 1, 4])
y = np.ones([3, 4])
tf.add(x, y).shape.as_list()
[1, 2, 3, 4]

Версия этой поэлементной операции с сокращением — tf.math.reduce_sum

__and__

__and__(
    y, name=None
)

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

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

Требуется, чтобы x и y имели одинаковую форму или имели совместимые для векторизации формы. Например, x и y могут быть:

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

Также можно использовать оператор &.

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

a = tf.constant([True])
b = tf.constant([False])
tf.math.logical_and(a, b)
<tf.Tensor: shape=(1,), dtype=bool, numpy=array([False])>
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])>
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])>
y & z
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False, False, False, True])>

Данная операция также поддерживает векторизацию.

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

Версия этой поэлементной операции с сокращением — tf.math.reduce_all.

__bool__

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

__bool__()

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

__div__

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

__div__(
    y, name=None
)

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

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

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

__eq__

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

__eq__(
    other
)

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

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

Цель в API:

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

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

__floordiv__

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

__floordiv__(
    y, name=None
)

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

Математически это эквивалентно floor(x / y). Например: floor(8.4 / 4.0) = floor(2.1) = 2.0 floor(-8.4 / 4.0) = floor(-2.1) = -3.0 Это эквивалентно оператору '//' в Python 3.0 и выше.

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

__ge__

__ge__(
    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__(
    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__(
    name=None
)

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

Пример:

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

__le__

__le__(
    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__(
    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__(
    y, name=None
)

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

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

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

__mul__

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

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

Результирующая версия этой поэлементной операции — tf.math.reduce_prod

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

__ne__

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

__ne__(
    other
)

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

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

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

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

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

__neg__

__neg__(
    name=None
)

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

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

__nonzero__

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

__nonzero__()

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

__or__

__or__(
    y, name=None
)

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

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

Требует, чтобы x и y имели одинаковую форму или имели совместимые по трансляции формы. Например, x и y могут быть:

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

Вы также можете использовать оператор |.

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

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

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

Эта операция также поддерживает трансляцию.

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

Результирующая версия этой поэлементной операции — tf.math.reduce_any.

__pow__

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

__pow__(
    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__(
    y, name=None
)

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

Примеры использования ниже.

Добавление скаляра и списка:

x = [1, 2, 3, 4, 5]
y = 1
tf.add(x, y)
<tf.Tensor: shape=(5,), dtype=int32, numpy=array([2, 3, 4, 5, 6],
dtype=int32)>

Обратите внимание, что вместо этого можно использовать бинарный оператор +:

x = tf.convert_to_tensor([1, 2, 3, 4, 5])
y = tf.convert_to_tensor(1)
x + y
<tf.Tensor: shape=(5,), dtype=int32, numpy=array([2, 3, 4, 5, 6],
dtype=int32)>

Добавление тензора и списка той же формы:

x = [1, 2, 3, 4, 5]
y = tf.constant([1, 2, 3, 4, 5])
tf.add(x, y)
<tf.Tensor: shape=(5,), dtype=int32,
numpy=array([ 2,  4,  6,  8, 10], dtype=int32)>

Например,

x = tf.constant([1, 2], dtype=tf.int8)
y = [2**7 + 1, 2**7 + 2]
tf.add(x, y)
<tf.Tensor: shape=(2,), dtype=int8, numpy=array([-126, -124], dtype=int8)>

При добавлении двух входных значений с различными формами Add следуют правила трансляции NumPy. Формы двух входных массивов сравниваются поэлементно. Начиная с последних измерений, два измерения должны быть равны или одно из них должно быть 1.

Например,

x = np.ones(6).reshape(1, 2, 1, 3)
y = np.ones(6).reshape(2, 1, 3, 1)
tf.add(x, y).shape.as_list()
[2, 2, 3, 3]

Еще один пример с двумя массивами разной размерности.

x = np.ones([1, 2, 1, 4])
y = np.ones([3, 4])
tf.add(x, y).shape.as_list()
[1, 2, 3, 4]

Результирующая версия этой поэлементной операции — tf.math.reduce_sum

__rand__

__rand__(
    y, name=None
)

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

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

Требуется, чтобы x и y имели одинаковую форму или имели совместимые для трансляции формы. Например, x и y могут быть:

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

Вы также можете использовать оператор & вместо него.

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

a = tf.constant([True])
b = tf.constant([False])
tf.math.logical_and(a, b)
<tf.Tensor: shape=(1,), dtype=bool, numpy=array([False])>
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])>
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])>
y & z
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False, False, False, True])>

Эта операция также поддерживает трансляцию.

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

Функция сокращения этой поэлементной операции — tf.math.reduce_all.

__rdiv__

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

__rdiv__(
    y, name=None
)

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

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

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

__rfloordiv__

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

__rfloordiv__(
    y, name=None
)

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

Математически это эквивалентно floor(x / y). Например: floor(8.4 / 4.0) = floor(2.1) = 2.0 floor(-8.4 / 4.0) = floor(-2.1) = -3.0 Это эквивалентно оператору '//' в Python 3.0 и выше.

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

__rmod__

__rmod__(
    y, name=None
)

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

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

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

__rmul__

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

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

Функция сокращения этой поэлементной операции — tf.math.reduce_prod

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

__ror__

__ror__(
    y, name=None
)

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

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

Требуется, чтобы x и y имели одинаковую форму или имели совместимые для трансляции формы. Например, x и y могут быть:

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

Вы также можете использовать оператор | вместо него.

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

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

c = tf.constant([False])
x = tf.constant([False, True, True, False])
tf.math.logical_or(c, x)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False, True,  True, False])>
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_or(y, z)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False, True, True, True])>
y | z
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False, True, True, True])>

Этот оператор также поддерживает трансляцию.

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

Версия сокращения этой элементной операции — tf.math.reduce_any.

__rpow__

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

__rpow__(
    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__(
    y, name=None
)

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

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

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

Примеры использования ниже.

Операция вычитания между массивом и скаляром:

x = [1, 2, 3, 4, 5]
y = 1
tf.subtract(x, y)
<tf.Tensor: shape=(5,), dtype=int32, numpy=array([0, 1, 2, 3, 4], dtype=int32)>
tf.subtract(y, x)
<tf.Tensor: shape=(5,), dtype=int32,
numpy=array([ 0, -1, -2, -3, -4], dtype=int32)>

Обратите внимание, что бинарный оператор - может быть использован вместо этого:

x = tf.convert_to_tensor([1, 2, 3, 4, 5])
y = tf.convert_to_tensor(1)
x - y
<tf.Tensor: shape=(5,), dtype=int32, numpy=array([0, 1, 2, 3, 4], dtype=int32)>

Операция вычитания между массивом и тензором той же формы:

x = [1, 2, 3, 4, 5]
y = tf.constant([5, 4, 3, 2, 1])
tf.subtract(y, x)
<tf.Tensor: shape=(5,), dtype=int32,
numpy=array([ 4,  2,  0, -2, -4], dtype=int32)>

Например,

x = tf.constant([1, 2], dtype=tf.int8)
y = [2**8 + 1, 2**8 + 2]
tf.subtract(x, y)
<tf.Tensor: shape=(2,), dtype=int8, numpy=array([0, 0], dtype=int8)>

При вычитании двух входных значений с разными формами tf.subtract следует правилам общего трансляции. Две формы входных массивов сравниваются по элементам. Начиная с хвостовых измерений, два измерения должны быть равны или одно из них должно быть 1.

Например,

x = np.ones(6).reshape(2, 3, 1)
y = np.ones(6).reshape(2, 1, 3)
tf.subtract(x, y)
<tf.Tensor: shape=(2, 3, 3), dtype=float64, numpy=
array([[[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]],
       [[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]]])>

Пример со входами разных измерений:

x = np.ones(6).reshape(2, 3, 1)
y = np.ones(6).reshape(1, 6)
tf.subtract(x, y)
<tf.Tensor: shape=(2, 3, 6), dtype=float64, numpy=
array([[[0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.]],
       [[0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.]]])>

__rtruediv__

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

__rtruediv__(
    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__(
    y, name='LogicalXor'
)

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

x ^ y = (x | y) & ~(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__(
    y, name=None
)

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

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

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

Примеры использования ниже.

Операция вычитания между массивом и скаляром:

x = [1, 2, 3, 4, 5]
y = 1
tf.subtract(x, y)
<tf.Tensor: shape=(5,), dtype=int32, numpy=array([0, 1, 2, 3, 4], dtype=int32)>
tf.subtract(y, x)
<tf.Tensor: shape=(5,), dtype=int32,
numpy=array([ 0, -1, -2, -3, -4], dtype=int32)>

Обратите внимание, что вместо этого можно использовать бинарный - оператор:

x = tf.convert_to_tensor([1, 2, 3, 4, 5])
y = tf.convert_to_tensor(1)
x - y
<tf.Tensor: shape=(5,), dtype=int32, numpy=array([0, 1, 2, 3, 4], dtype=int32)>

Операция вычитания между массивом и тензором той же формы:

x = [1, 2, 3, 4, 5]
y = tf.constant([5, 4, 3, 2, 1])
tf.subtract(y, x)
<tf.Tensor: shape=(5,), dtype=int32,
numpy=array([ 4,  2,  0, -2, -4], dtype=int32)>

Например,

x = tf.constant([1, 2], dtype=tf.int8)
y = [2**8 + 1, 2**8 + 2]
tf.subtract(x, y)
<tf.Tensor: shape=(2,), dtype=int8, numpy=array([0, 0], dtype=int8)>

При вычитании двух входных значений с разными формами, tf.subtract следует общим правилам векторизации. Формы двух массивов входных данных сравниваются поэлементно. Начиная с последних измерений, два измерения должны быть равны или одно из них должно быть 1.

Например,

x = np.ones(6).reshape(2, 3, 1)
y = np.ones(6).reshape(2, 1, 3)
tf.subtract(x, y)
<tf.Tensor: shape=(2, 3, 3), dtype=float64, numpy=
array([[[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]],
       [[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]]])>

Пример с входными данными разных измерений:

x = np.ones(6).reshape(2, 3, 1)
y = np.ones(6).reshape(1, 6)
tf.subtract(x, y)
<tf.Tensor: shape=(2, 3, 6), dtype=float64, numpy=
array([[[0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.]],
       [[0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.]]])>

__truediv__

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

__truediv__(
    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__(
    y, name='LogicalXor'
)

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

x ^ y = (x | y) & ~(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])>