tf.RaggedTensor

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

Используется в блокнотах

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

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

Потенциально разреженные тензоры

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

Описание форм RaggedTensor

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

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

Внутренне RaggedTensor состоит из объединённого списка значений, разделённых на строки переменной длины. В частности, каждый RaggedTensor состоит из:

• Тензора 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 с несколькими разреженными измерениями можно определить, используя вложенный 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 можно использовать для непосредственного создания RaggedTensor с несколькими разреженными измерениями, передав список тензоров 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], []]]

Равномерные внутренние измерения

RaggedTensor с равномерными внутренними измерениями можно определить, используя многомерный 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 с равномерными внешними измерениями можно определить, используя один или несколько RaggedTensor с тензором разбиения на строки uniform_row_length. Например, 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)
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 содержит только одно разреженное измерение (самое внутреннее измерение). В отличие от него, если для создания похожего RaggedTensor использовать from_row_splits, то этот RaggedTensor будет иметь два разреженных измерения:

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

Равномерные и разреженные внешние измерения можно чередовать, то есть можно создать тензор с любой комбинацией разреженных и равномерных измерений. Например, RaggedTensor 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
)

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

Пример:

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

consumers

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

consumers()

from_nested_row_lengths

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

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

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

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

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

from_nested_row_splits

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

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

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

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

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

from_nested_value_rowids

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

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

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

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

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

from_row_lengths

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

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

Создаёт RaggedTensor, строки которого разбиты согласно row_lengths.

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

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

Пример:

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

from_row_limits

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

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

Создаёт RaggedTensor, строки которого разбиты согласно row_limits.

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

Пример:

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

from_row_splits

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

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

Создаёт RaggedTensor, строки которого разбиты согласно row_splits.

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

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

Пример:

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

from_row_starts

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

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

Создаёт RaggedTensor, строки которого разбиты согласно row_starts.

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

Пример:

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

from_sparse

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

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

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

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

Пример:

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

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

from_tensor

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

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

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

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

Примеры:

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

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

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

from_uniform_row_length

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

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

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

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

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

Обратите внимание, что rt1 содержит только одно нерегулярное измерение (самое внутреннее измерение). В отличие от этого, если для создания похожего RaggedTensor использовать from_row_splits, такой 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() -> tf.TensorShape

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

Псевдоним свойства 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
)

Объединяет 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
)

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

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
)

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

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

Пример:

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

Нерегулярные измерения кодируются с помощью массивов 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
)

Возвращает длины строк этого ragged-тензора.

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
)

Возвращает индексы конца строк этого ragged-тензора.

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

Возвращает начальные индексы строк этого ragged-тензора.

Эти индексы задают положение, с которого начинаются значения каждой строки в 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 execution.

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 в этом ragged-тензоре.

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

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

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

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

Например:

# real number
x = tf.ragged.constant([[-2.2, 3.2], [-4.2]])
tf.abs(x)
<tf.RaggedTensor [[2.2, 3.2], [4.2]]>

# complex number
x = tf.ragged.constant([[-2.2 + 4.7j], [-3.2 + 5.7j], [-4.2 + 6.7j]])
tf.abs(x)
<tf.RaggedTensor [[5.189412298131649],
 [6.536818798161687],
 [7.907591289387685]]>

__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 должны совпадать или быть совместимыми для вещания. Например, y может быть:

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

Например:

# `y` is a Python boolean
x = tf.ragged.constant([[True, False], [True]])
y = True
x & y
<tf.RaggedTensor [[True, False], [True]]>
tf.math.logical_and(x, y)  # Equivalent of x & y
<tf.RaggedTensor [[True, False], [True]]>
y & x
<tf.RaggedTensor [[True, False], [True]]>
tf.math.reduce_all(x & y)  # Reduce to a scalar bool Tensor.
<tf.Tensor: shape=(), dtype=bool, numpy=False>

# `y` is a tf.Tensor of the same shape.
x = tf.ragged.constant([[True, False], [True, False]])
y = tf.constant([[True, False], [False, True]])
x & y
<tf.RaggedTensor [[True, False], [False, False]]>

# `y` is a tf.Tensor of a broadcast-compatible shape.
x = tf.ragged.constant([[True, False], [True]])
y = tf.constant([[True], [False]])
x & y
<tf.RaggedTensor [[True, False], [False]]>

# `y` is a `tf.RaggedTensor` of the same shape.
x = tf.ragged.constant([[True, False], [True]])
y = tf.ragged.constant([[False, True], [True]])
x & y
<tf.RaggedTensor [[False, False], [True]]>

# `y` is a `tf.RaggedTensor` of a broadcast-compatible shape.
x = tf.ragged.constant([[[True, True, False]], [[]], [[True, False]]])
y = tf.ragged.constant([[[True]], [[True]], [[False]]], ragged_rank=1)
x & y
<tf.RaggedTensor [[[True, True, False]], [[]], [[False, False]]]>

__bool__

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

__bool__()

Вызывает TypeError, если RaggedTensor используется как логическое значение Python.

Чтобы предотвратить использование RaggedTensor в качестве логического значения, эта функция всегда вызывает TypeError при вызове.

Например:

x = tf.ragged.constant([[1, 2], [3]])
result = True if x else False  # Evaluate x as a bool value.
Traceback (most recent call last):

TypeError: RaggedTensor may not be used as a boolean.

x = tf.ragged.constant([[1]])
r = (x == 1)  # tf.RaggedTensor [[True]]
if r:  # Evaluate r as a bool value.
  pass
Traceback (most recent call last):

TypeError: RaggedTensor may not be used as a boolean.

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

Возвращает результат поэлементного сравнения == или False, если формы несовместимы для вещания.

Поэлементно сравнивает два рваных тензора на равенство, если их формы совместимы для вещания; в противном случае возвращает False.

Обратите внимание, что такое поведение отличается от поведения tf.math.equal, которое вызывает исключение, если формы двух рваных тензоров несовместимы для вещания.

Например:

rt1 = tf.ragged.constant([[1, 2], [3]])
rt1 == rt1
<tf.RaggedTensor [[True, True], [True]]>

rt2 = tf.ragged.constant([[1, 2], [4]])
rt1 == rt2
<tf.RaggedTensor [[True, True], [False]]>

rt3 = tf.ragged.constant([[1, 2], [3, 4]])
# rt1 and rt3 are not broadcast-compatible.
rt1 == rt3
False

# You can also compare a `tf.RaggedTensor` to a `tf.Tensor`.
t = tf.constant([[1, 2], [3, 4]])
rt1 == t
False
t == rt1
False
rt4 = tf.ragged.constant([[1, 2], [3, 4]])
rt4 == t
<tf.RaggedTensor [[True, True], [True, True]]>
t == rt4
<tf.RaggedTensor [[True, True], [True, True]]>

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

Поэлементное сравнение >= двух значений, преобразуемых в рваные тензоры.

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

Например:

rt1 = tf.ragged.constant([[1, 2], [3]])
rt1 >= rt1
<tf.RaggedTensor [[True, True], [True]]>

rt2 = tf.ragged.constant([[2, 1], [3]])
rt1 >= rt2
<tf.RaggedTensor [[False, True], [True]]>

rt3 = tf.ragged.constant([[1, 2], [3, 4]])
# rt1 and rt3 are not broadcast-compatible.
rt1 >= rt3
Traceback (most recent call last):

InvalidArgumentError: ...

# You can also compare a `tf.RaggedTensor` to a `tf.Tensor`.
rt4 = tf.ragged.constant([[1, 2],[3, 4]])
t1 = tf.constant([[2, 1], [4, 3]])
rt4 >= t1
<tf.RaggedTensor [[False, True],
 [False, True]]>
t1 >= rt4
<tf.RaggedTensor [[True, False],
 [True, False]]>

# Compares a `tf.RaggedTensor` to a `tf.Tensor` with broadcasting.
t2 = tf.constant([[2]])
rt4 >= t2
<tf.RaggedTensor [[False, True],
 [True, True]]>
t2 >= rt4
<tf.RaggedTensor [[True, True],
 [False, False]]>

__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: Annotated[Any, tf.raw_ops.Any],
    name=None
) -> Annotated[Any, tf.raw_ops.Any]

Поэлементно возвращает логическое значение выражения (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
) -> Annotated[Any, tf.raw_ops.Any]

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

Пример:

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

__le__

__le__(
    y: Annotated[Any, tf.raw_ops.Any],
    name=None
) -> Annotated[Any, tf.raw_ops.Any]

Поэлементно возвращает логическое значение выражения (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: Annotated[Any, tf.raw_ops.Any],
    name=None
) -> Annotated[Any, tf.raw_ops.Any]

Поэлементно возвращает логическое значение выражения (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: Annotated[Any, tf.raw_ops.Any],
    name=None
) -> Annotated[Any, tf.raw_ops.Any]

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

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

Примечание: 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, которое вызывает исключение, если формы двух тензоров несовместимы для вещания.)

__neg__

__neg__(
    name=None
) -> Annotated[Any, tf.raw_ops.Any]

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

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

__nonzero__

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

__nonzero__()

Вызывает TypeError, если RaggedTensor используется как логическое значение Python.

Чтобы предотвратить использование RaggedTensor в качестве логического значения, эта функция всегда вызывает TypeError при вызове.

Например:

x = tf.ragged.constant([[1, 2], [3]])
result = True if x else False  # Evaluate x as a bool value.
Traceback (most recent call last):

TypeError: RaggedTensor may not be used as a boolean.

x = tf.ragged.constant([[1]])
r = (x == 1)  # tf.RaggedTensor [[True]]
if r:  # Evaluate r as a bool value.
  pass
Traceback (most recent call last):

TypeError: RaggedTensor may not be used as a boolean.

__or__

__or__(
    y: Annotated[Any, tf.raw_ops.Any],
    name=None
) -> Annotated[Any, tf.raw_ops.Any]

Возвращает поэлементное логическое значение 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])>

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.

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

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

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

• Отдельным логическим значением Python; в этом случае результат вычисляется путём применения логического И с этим отдельным элементом к каждому элементу x.
• Объектом tf.Tensor с типом данных tf.bool, имеющим ту же форму или совместимую для трансляции форму. В этом случае результатом будет поэлементное логическое И x и y.
• Объектом tf.RaggedTensor с типом данных tf.bool, имеющим ту же форму или совместимую для трансляции форму. В этом случае результатом будет поэлементное логическое И x и y.

Например:

# `y` is a Python boolean
x = tf.ragged.constant([[True, False], [True]])
y = True
x & y
<tf.RaggedTensor [[True, False], [True]]>
tf.math.logical_and(x, y)  # Equivalent of x & y
<tf.RaggedTensor [[True, False], [True]]>
y & x
<tf.RaggedTensor [[True, False], [True]]>
tf.math.reduce_all(x & y)  # Reduce to a scalar bool Tensor.
<tf.Tensor: shape=(), dtype=bool, numpy=False>

# `y` is a tf.Tensor of the same shape.
x = tf.ragged.constant([[True, False], [True, False]])
y = tf.constant([[True, False], [False, True]])
x & y
<tf.RaggedTensor [[True, False], [False, False]]>

# `y` is a tf.Tensor of a broadcast-compatible shape.
x = tf.ragged.constant([[True, False], [True]])
y = tf.constant([[True], [False]])
x & y
<tf.RaggedTensor [[True, False], [False]]>

# `y` is a `tf.RaggedTensor` of the same shape.
x = tf.ragged.constant([[True, False], [True]])
y = tf.ragged.constant([[False, True], [True]])
x & y
<tf.RaggedTensor [[False, False], [True]]>

# `y` is a `tf.RaggedTensor` of a broadcast-compatible shape.
x = tf.ragged.constant([[[True, True, False]], [[]], [[True, False]]])
y = tf.ragged.constant([[[True]], [[True]], [[False]]], ragged_rank=1)
x & y
<tf.RaggedTensor [[[True, True, False]], [[]], [[False, False]]]>

__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: Annotated[Any, tf.raw_ops.Any],
    name=None
) -> Annotated[Any, tf.raw_ops.Any]

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

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

Примечание: 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

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

__ror__

__ror__(
    y: Annotated[Any, tf.raw_ops.Any],
    name=None
) -> Annotated[Any, tf.raw_ops.Any]

Возвращает поэлементное логическое значение 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])>

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

Функция логического исключающего ИЛИ.

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

Примечание: Рекомендуется использовать оператор 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).

__xor__

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

__xor__(
    y, name='LogicalXor'
)

Функция логического исключающего ИЛИ.

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