tf.RaggedTensor

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

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

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

Преобразует двумерный tf.sparse.SparseTensor в RaggedTensor.

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

Пример:

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

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

from_tensor

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

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

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

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

Примеры:

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

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

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

from_uniform_row_length

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

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

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

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

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

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

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

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

from_value_rowids

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

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

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

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

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

Пример:

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

get_shape

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

get_shape() -> tf.TensorShape

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

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

Примеры:

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

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

merge_dims

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

merge_dims(
    outer_axis, inner_axis
)

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

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

Примеры:

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

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

nested_row_lengths

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

nested_row_lengths(
    name=None
)

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

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

nested_value_rowids

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

nested_value_rowids(
    name=None
)

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

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

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

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

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

Примеры

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

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

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

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

row_lengths

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

row_lengths(
    axis=1, name=None
)

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

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

Пример:

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

row_limits

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

row_limits(
    name=None
)

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

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

Пример:

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

row_starts

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

row_starts(
    name=None
)

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

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

Пример:

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

to_list

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

to_list()

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

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

to_sparse

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

to_sparse(
    name=None
)

Преобразует этот разреженный тензор в 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
)

Преобразует этот разреженный тензор в 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.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 bool.

Чтобы предотвратить использование RaggedTensor в качестве bool, эта функция всегда вызывает 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

A 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 bool.

Чтобы предотвратить использование RaggedTensor в качестве bool, эта функция всегда вызывает 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 boolean, где результат вычисляется путём применения логического И с отдельным элементом к каждому элементу в 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

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

__ror__

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

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

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

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

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

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

>>> 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, где все целочисленные аргументы сначала преобразуются к плавающим типам. Этот op генерируется обычным оператором деления 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])>