tf.RaggedTensor

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

tf.RaggedTensor(
    values, row_splits, cached_row_lengths=None, cached_value_rowids=None,
    cached_nrows=None, internal=False
)

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

Множественные разряженные измерения

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

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

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

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

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

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

rt = RaggedTensor.from_row_splits(values=tf.ones([5, 3]),
..                                    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, ?, 3)

Ограничения формы RaggedTensor

Форма разряженного тензора в настоящее время ограничена следующей формой:

• Одно однородное измерение
• За ним следует одно или несколько разряженных измерений
• За ним следует ноль или более однородных измерений.

Это ограничение вытекает из того, что каждый вложенный RaggedTensor заменяет однородное внешнее измерение его values на однородное измерение, за которым следует разряженное измерение.

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

rt = 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))
Splits for dimension 1: [0, 1]
Splits for dimension 2: [0, 3, 3, 5]
Splits for dimension 3: [0, 4, 4, 7, 8, 8]

>>> rt = 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])

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

Методы

bounding_shape

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

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

Возвращает форму ограничивающей прямоугольной области для данного разряженного тензора.

Пример:

>>> rt = ragged.constant([[1, 2, 3, 4], [5], [], [6, 7, 8, 9], [10]])
>>> rt.bounding_shape()
[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.SparseTensor в RaggedTensor.

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

Пример:

st = SparseTensor(indices=[[0, 1], [0, 2], [0, 3], [1, 0], [3, 0]],
                  values=[1, 2, 3, 4, 5],
                  dense_shape=[4, 3])
rt.RaggedTensor.from_sparse(st).eval().tolist()
[[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)

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dt = tf.constant([[[5, 0], [7, 0], [0, 0]],</code>
<code class="no-select nocode">                      [[0, 0], [3, 0], [0, 0]],</code>
<code class="no-select nocode">                      [[6, 0], [0, 0], [0, 0]]])</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">tf.RaggedTensor.from_tensor(dt, lengths=([2, 0, 3], [1, 1, 2, 0, 1]))</code>
<code class="no-select nocode">&lt;tf.RaggedTensor [[[5], [7]], [], [[6, 0], [], [0]]]&gt;</code>
</pre>

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

nested_row_lengths

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

nested_row_lengths(
    name=None
)

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

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

nested_value_rowids

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

nested_value_rowids(
    name=None
)

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

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

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

Пример:

rt = 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))
  row ids for dimension 1: [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 = ragged.constant([[3, 1, 4, 1], [], [5, 9, 2], [6], []])
>>> rt.nrows()  # rt has 5 rows.
5

row_lengths

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

row_lengths(
    axis=1, name=None
)

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

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

Пример:

>>> rt = ragged.constant([[[3, 1, 4], [1]], [], [[5, 9], [2]], [[6]], []])
>>> rt.row_lengths(rt)  # lengths of rows in rt
tf.Tensor([2, 0, 2, 1, 0])
>>> 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 = ragged.constant([[3, 1, 4, 1], [], [5, 9, 2], [6], []])
>>> rt.values
tf.Tensor([3, 1, 4, 1, 5, 9, 2, 6])
>>> rt.row_limits()  # indices of row limits in rt.values
tf.Tensor([4, 4, 7, 8, 8])

row_starts

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

row_starts(
    name=None
)

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

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

Пример:

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

to_list

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

to_list()

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

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

to_sparse

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

to_sparse(
    name=None
)

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

Пример:

rt = ragged.constant([[1, 2, 3], [4], [], [5, 6]])
rt.to_sparse().eval()
SparseTensorValue(indices=[[0, 0], [0, 1], [0, 2], [1, 0], [3, 0], [3, 1]],
                  values=[1, 2, 3, 4, 5, 6],
                  dense_shape=[4, 3])

to_tensor

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

to_tensor(
    default_value=None, name=None
)

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

Пример:

rt = ragged.constant([[9, 8, 7], [], [6, 5], [4]])
print rt.to_tensor()
[[9 8 7]
 [0 0 0]
 [6 5 0]
 [4 0 0]]

value_rowids

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

value_rowids(
    name=None
)

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

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

Пример:

>>> rt = ragged.constant([[3, 1, 4, 1], [], [5, 9, 2], [6], []])
>>> rt.values
tf.Tensor([3, 1, 4, 1, 5, 9, 2, 6])
>>> rt.value_rowids()
tf.Tensor([0, 0, 0, 0, 2, 2, 2, 3])  # corresponds 1:1 with rt.values

with_flat_values

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

with_flat_values(
    new_values
)

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

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

with_row_splits_dtype

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

with_row_splits_dtype(
    dtype
)

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

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

with_values

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

with_values(
    new_values
)

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

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

__abs__

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

__abs__(
    x, name=None
)

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

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

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

x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])
tf.abs(x)  # [5.25594902, 6.60492229]

__add__

__add__(
    x, y, name=None
)

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

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

__and__

__and__(
    x, y, name=None
)

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

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

__bool__

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

__bool__(
    _
)

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

__div__

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

__div__(
    x, y, name=None
)

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

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

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

__floordiv__

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

__floordiv__(
    x, y, name=None
)

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

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

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

__ge__

__ge__(
    x, y, name=None
)

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

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

__getitem__

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

__getitem__(
    key
)

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

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

Любые измерения, добавленные array_ops.newaxis, будут разреженными, если следующий размер разреженный.

Примеры:

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

Трехмерный раздробленный тензор с двумя раздробленными измерениями.

rt = ragged.constant([[[1, 2, 3], [4]], ... [[5], [], [6]], ... [[7]], ... [[8, 9], [10]]]) rt[1].eval().tolist() # Вторая строка (2-мерный раздробленный тензор) [[5], [], [6]] rt[3, 0].eval().tolist() # Первый элемент четвёртой строки (1-мерный тензор) [8, 9] rt[:, 1:3].eval().tolist() # Элементы 1-3 каждой строки (3-мерный раздробленный тензор) [[[4]], [[], [6]], [], [[10]]] rt[:, -1:].eval().tolist() # Последний элемент каждой строки (3-мерный раздробленный тензор) [[[4]], [[6]], [[7]], [[10]]]

__gt__

__gt__(
    x, y, name=None
)

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

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

__invert__

__invert__(
    x, name=None
)

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

__le__

__le__(
    x, y, name=None
)

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

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

__lt__

__lt__(
    x, y, name=None
)

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

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

__mod__

__mod__(
    x, y, name=None
)

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

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

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

__mul__

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

__mul__(
    x, y, name=None
)

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

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

__neg__

__neg__(
    x, name=None
)

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

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

__nonzero__

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

__nonzero__(
    _
)

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

__or__

__or__(
    x, y, name=None
)

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

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

__pow__

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

__pow__(
    x, y, name=None
)

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

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

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

__radd__

__radd__(
    x, y, name=None
)

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

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

__rand__

__rand__(
    x, y, name=None
)

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

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

__rdiv__

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

__rdiv__(
    x, y, name=None
)

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

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

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

__rfloordiv__

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

__rfloordiv__(
    x, y, name=None
)

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

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

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

__rmod__

__rmod__(
    x, y, name=None
)

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

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

__rmul__

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

__rmul__(
    x, y, name=None
)

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

Примечание: tf.multiply поддерживает вещание. Дополнительную информацию о вещании можно найти здесь

__ror__

__ror__(
    x, y, name=None
)

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

Примечание: math.logical_or поддерживает вещание. Дополнительная информация о вещании здесь

__rpow__

View source

__rpow__(
    x, y, name=None
)

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

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

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

__rsub__

View source

__rsub__(
    x, y, name=None
)

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

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

__rtruediv__

View source

__rtruediv__(
    x, y, name=None
)

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

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

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

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

__rxor__

View source

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

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

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

Вводятся тензоры, и если тензоры содержат более одного элемента, вычисляется побитовое логическое XOR.

Usage:

x = tf.constant([False, False, True, True], dtype = tf.bool)
y = tf.constant([False, True, False, True], dtype = tf.bool)
z = tf.logical_xor(x, y, name="LogicalXor")
#  here z = [False  True  True False]

__sub__

View source

__sub__(
    x, y, name=None
)

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

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

__truediv__

View source

__truediv__(
    x, y, name=None
)

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

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

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

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

__xor__

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

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

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

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

Ввод — это тензор, и если тензор содержит более одного элемента, вычисляется поэлементное логическое XOR.

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

x = tf.constant([False, False, True, True], dtype = tf.bool)
y = tf.constant([False, True, False, True], dtype = tf.bool)
z = tf.logical_xor(x, y, name="LogicalXor")
#  here z = [False  True  True False]