tf.Tensor

Тензор — это многомерный массив элементов, представленный в

tf.Tensor(
    op, value_index, dtype
)

tf.Tensor объект. Все элементы имеют один и тот же известный тип данных.

При написании программы TensorFlow основной объект, который обрабатывается и передаётся, — это tf.Tensor.

У tf.Tensor есть следующие свойства:

• один тип данных (например, float32, int32 или string)
• форма

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

TensorFlow по умолчанию работает в режиме eager. В примере ниже результаты умножения матриц вычисляются немедленно.

# Compute some values using a Tensor
c = tf.constant([[1.0, 2.0], [3.0, 4.0]])
d = tf.constant([[1.0, 1.0], [0.0, 1.0]])
e = tf.matmul(c, d)
print(e)
tf.Tensor(
[[1. 3.]
 [3. 7.]], shape=(2, 2), dtype=float32)

Обратите внимание, что во время исполнения в режиме eager вы можете обнаружить, что ваши Tensors фактически имеют тип EagerTensor. Это внутренняя деталь, но она даёт вам доступ к полезной функции, numpy:

type(e)
<class '...ops.EagerTensor'>
print(e.numpy())
  [[1. 3.]
   [3. 7.]]

В TensorFlow tf.function — распространённый способ определения исполнения в режиме построения графа.

Форма тензора (то есть ранг тензора и размерность каждого измерения) может быть не всегда полностью известной. В определениях tf.function форма может быть частично неизвестной.

Большинство операций производят тензоры с полностью известными формами, если формы их входных данных также полностью известны, но в некоторых случаях форму тензора можно определить только во время выполнения.

Доступны несколько специализированных тензоров: см. tf.Variable, tf.constant, tf.placeholder, tf.sparse.SparseTensor и tf.RaggedTensor.

Дополнительную информацию о тензорах см. в руководстве.

t = tf.constant([1,2,3,4,5])
t.shape
TensorShape([5])

Методы

consumers

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

consumers()

Возвращает список Operations, которые потребляют этот тензор.

eval

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

eval(
    feed_dict=None, session=None
)

Вычисляет этот тензор в Session.

Примечание: Если вы не используете библиотеки compat.v1, вам это не нужно (или feed_dict или Session). При использовании неявного выполнения (или внутри tf.function) вы не должны вызывать eval.

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

Примечание: Перед вызовом Tensor.eval() его граф должен быть запущен в сессии, и либо должна быть доступна сессия по умолчанию, либо session должна быть явно указана.

experimental_ref

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

experimental_ref()

УСТАРЕВШАЯ ФУНКЦИЯ

get_shape

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

get_shape()

Возвращает tf.TensorShape, представляющую форму этого тензора.

При неявном выполнении форма всегда полностью известна.

a = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
print(a.shape)
(2, 3)

tf.Tensor.get_shape() эквивалентно tf.Tensor.shape.

При выполнении в tf.function или построении модели с использованием tf.keras.Input, Tensor.shape может вернуть частичную форму (включая None для неизвестных размерностей). См. tf.TensorShape для получения дополнительной информации.

inputs = tf.keras.Input(shape = [10])
# Unknown batch size
print(inputs.shape)
(None, 10)

Форма вычисляется с использованием функций вывода формы, зарегистрированных для каждой tf.Operation.

Возвращаемый tf.TensorShape определяется на этапе *создания*, без выполнения базового ядра. Это не tf.Tensor. Если вам нужна форма *тензора*, либо преобразуйте tf.TensorShape в tf.constant, либо используйте функцию tf.shape(tensor), которая возвращает форму тензора на этапе *выполнения*.

Это полезно для отладки и предоставления ранних ошибок. Например, при трассировке tf.function операции не выполняются, формы могут быть неизвестны (см. руководство по конкретным функциям Руководство по конкретным функциям для получения дополнительной информации).

@tf.function
def my_matmul(a, b):
  result = a@b
  # the `print` executes during tracing.
  print("Result shape: ", result.shape)
  return result

Функции вывода формы распространяют формы по возможности:

f = my_matmul.get_concrete_function(
  tf.TensorSpec([None,3]),
  tf.TensorSpec([3,5]))
Result shape: (None, 5)

Трассировка может завершиться неудачно, если будет обнаружен несовпадение форм:

cf = my_matmul.get_concrete_function(
  tf.TensorSpec([None,3]),
  tf.TensorSpec([4,5]))
Traceback (most recent call last):

ValueError: Dimensions must be equal, but are 3 and 4 for 'matmul' (op:
'MatMul') with input shapes: [?,3], [4,5].

В некоторых случаях выведенная форма может иметь неизвестные размерности. Если у вызывающей стороны есть дополнительная информация о значениях этих размерностей, можно использовать Tensor.set_shape() для дополнения выведенной формы.

@tf.function
def my_fun(a):
  a.set_shape([5, 5])
  # the `print` executes during tracing.
  print("Result shape: ", a.shape)
  return a

cf = my_fun.get_concrete_function(
  tf.TensorSpec([None, None]))
Result shape: (5, 5)

ref

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

ref()

Возвращает хэшируемый объект ссылки на этот тензор.

Основной случай использования этого API — размещение тензоров в наборе/словаре. Мы не можем поместить тензоры в набор/словарь, так как tensor.__hash__() больше не доступен, начиная с TensorFlow 2.0.

Следующее вызовет исключение, начиная с версии 2.0

x = tf.constant(5)
y = tf.constant(10)
z = tf.constant(10)
tensor_set = {x, y, z}
Traceback (most recent call last):

TypeError: Tensor is unhashable. Instead, use tensor.ref() as the key.
tensor_dict = {x: 'five', y: 'ten'}
Traceback (most recent call last):

TypeError: Tensor is unhashable. Instead, use tensor.ref() as the key.

Вместо этого мы можем использовать tensor.ref().

tensor_set = {x.ref(), y.ref(), z.ref()}
x.ref() in tensor_set
True
tensor_dict = {x.ref(): 'five', y.ref(): 'ten', z.ref(): 'ten'}
tensor_dict[y.ref()]
'ten'

Кроме того, объект ссылки предоставляет функцию .deref(), которая возвращает исходный тензор.

x = tf.constant(5)
x.ref().deref()
<tf.Tensor: shape=(), dtype=int32, numpy=5>

set_shape

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

set_shape(
    shape
)

Обновляет форму этого тензора.

При использовании жадного выполнения это работает как утверждение формы. Здесь формы совпадают:

t = tf.constant([[1,2,3]])
t.set_shape([1, 3])

Передача None в новой форме позволяет любое значение для этой оси:

t.set_shape([1,None])

Возникает ошибка, если передана несовместимая форма.

t.set_shape([1,5])
Traceback (most recent call last):

ValueError: Tensor's shape (1, 3) is not compatible with supplied
shape [1, 5]

При выполнении в tf.function или построении модели с использованием tf.keras.Input, Tensor.set_shape будет сливать заданную shape с текущей формой этого тензора и устанавливать форму тензора в объединённое значение (см. tf.TensorShape.merge_with для подробностей):

t = tf.keras.Input(shape=[None, None, 3])
print(t.shape)
(None, None, None, 3)

Измерения, установленные на None, не обновляются:

t.set_shape([None, 224, 224, None])
print(t.shape)
(None, 224, 224, 3)

Основной случай использования — предоставление дополнительной информации о форме, которую нельзя вывести только из графа.

Например, если вы знаете, что все изображения в наборе данных имеют форму [28,28,3], вы можете установить её с помощью tf.set_shape:

@tf.function
def load_image(filename):
  raw = tf.io.read_file(filename)
  image = tf.image.decode_png(raw, channels=3)
  # the `print` executes during tracing.
  print("Initial shape: ", image.shape)
  image.set_shape([28, 28, 3])
  print("Final shape: ", image.shape)
  return image

Отследите функцию, см. Руководство по конкретным функциям для подробностей.

cf = load_image.get_concrete_function(
    tf.TensorSpec([], dtype=tf.string))
Initial shape:  (None, None, 3)
Final shape: (28, 28, 3)

Аналогично, функция tf.io.parse_tensor может возвращать тензор с любой формой, даже если tf.rank неизвестна. Если вы знаете, что все ваши сериализованные тензоры будут двумерными, установите это с помощью set_shape:

@tf.function
def my_parse(string_tensor):
  result = tf.io.parse_tensor(string_tensor, out_type=tf.float32)
  # the `print` executes during tracing.
  print("Initial shape: ", result.shape)
  result.set_shape([None, None])
  print("Final shape: ", result.shape)
  return result

Отследить функцию

concrete_parse = my_parse.get_concrete_function(
    tf.TensorSpec([], dtype=tf.string))
Initial shape:  <unknown>
Final shape:  (None, None)

Убедитесь, что это работает:

t = tf.ones([5,3], dtype=tf.float32)
serialized = tf.io.serialize_tensor(t)
print(serialized.dtype)
<dtype: 'string'>
print(serialized.shape)
()
t2 = concrete_parse(serialized)
print(t2.shape)
(5, 3)

# Serialize a rank-3 tensor
t = tf.ones([5,5,5], dtype=tf.float32)
serialized = tf.io.serialize_tensor(t)
# The function still runs, even though it `set_shape([None,None])`
t2 = concrete_parse(serialized)
print(t2.shape)
(5, 5, 5)

__abs__

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

__abs__(
    x, name=None
)

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

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

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

• b^2}\). Например:

x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])
tf.abs(x)
<tf.Tensor: shape=(2, 1), dtype=float64, numpy=
array([[5.25594901],
       [6.60492241]])>

__add__

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

__add__(
    x, y
)

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

Цель в API:

This method is exposed in TensorFlow's API so that library developers
can register dispatching for <a href="../tf/Tensor#__add__"><code>Tensor.__add__</code></a> to allow it to handle
custom composite tensors & other custom objects.

The API symbol is not intended to be called by users directly and does
appear in TensorFlow's generated documentation.

__and__

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

__and__(
    x, y
)

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

Операция работает для следующих типов входных данных:

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

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

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

c = tf.constant([True])
x = tf.constant([False, True, True, False])
tf.math.logical_and(c, x)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False,  True,  True, False])>

y = tf.constant([False, False, True, True])
z = tf.constant([False, True, False, True])
tf.math.logical_and(y, z)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False, False, False,  True])>

__bool__

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

__bool__()

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

Этот перегруз вызывает TypeError, когда пользователь непреднамеренно обрабатывает Tensor как булево значение (чаще всего в операторе if или while), в коде, который не был преобразован с помощью AutoGraph. Например:

if tf.constant(True):  # Will raise.
  # ...

if tf.constant(5) < tf.constant(7):  # Will raise.
  # ...

__div__

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

__div__(
    x, y
)

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

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

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

__eq__

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

__eq__(
    other
)

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

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

Цель в API:

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

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

__floordiv__

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

__floordiv__(
    x, y
)

Делит элементные значения, округляя в сторону наименьшего целого числа.

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

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

__ge__

__ge__(
    x, y, name=None
)

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

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

Пример:

x = tf.constant([5, 4, 6, 7])
y = tf.constant([5, 2, 5, 10])
tf.math.greater_equal(x, y) ==> [True, True, True, False]

x = tf.constant([5, 4, 6, 7])
y = tf.constant([5])
tf.math.greater_equal(x, y) ==> [True, False, True, True]

__getitem__

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

__getitem__(
    tensor, slice_spec, var=None
)

Перегрузка для Tensor.getitem.

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

Некоторые полезные примеры:

# Strip leading and trailing 2 elements
foo = tf.constant([1,2,3,4,5,6])
print(foo[2:-2].eval())  # => [3,4]

# Skip every other row and reverse the order of the columns
foo = tf.constant([[1,2,3], [4,5,6], [7,8,9]])
print(foo[::2,::-1].eval())  # => [[3,2,1], [9,8,7]]

# Use scalar tensors as indices on both dimensions
print(foo[tf.constant(0), tf.constant(2)].eval())  # => 3

# Insert another dimension
foo = tf.constant([[1,2,3], [4,5,6], [7,8,9]])
print(foo[tf.newaxis, :, :].eval()) # => [[[1,2,3], [4,5,6], [7,8,9]]]
print(foo[:, tf.newaxis, :].eval()) # => [[[1,2,3]], [[4,5,6]], [[7,8,9]]]
print(foo[:, :, tf.newaxis].eval()) # => [[[1],[2],[3]], [[4],[5],[6]],
[[7],[8],[9]]]

# Ellipses (3 equivalent operations)
foo = tf.constant([[1,2,3], [4,5,6], [7,8,9]])
print(foo[tf.newaxis, :, :].eval())  # => [[[1,2,3], [4,5,6], [7,8,9]]]
print(foo[tf.newaxis, ...].eval())  # => [[[1,2,3], [4,5,6], [7,8,9]]]
print(foo[tf.newaxis].eval())  # => [[[1,2,3], [4,5,6], [7,8,9]]]

# Masks
foo = tf.constant([[1,2,3], [4,5,6], [7,8,9]])
print(foo[foo > 2].eval())  # => [3, 4, 5, 6, 7, 8, 9]

Примечания:

• tf.newaxis эквивалентен None как в NumPy.
• Неявное эллипсис ставится в конце slice_spec
• Расширенная индексация NumPy в настоящее время не поддерживается.

Цель в API:

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

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

__gt__

__gt__(
    x, y, name=None
)

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

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

Пример:

x = tf.constant([5, 4, 6])
y = tf.constant([5, 2, 5])
tf.math.greater(x, y) ==> [False, True, True]

x = tf.constant([5, 4, 6])
y = tf.constant([5])
tf.math.greater(x, y) ==> [False, False, True]

__invert__

__invert__(
    x, name=None
)

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

Пример:

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

__iter__

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

__iter__()

__le__

__le__(
    x, y, name=None
)

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

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

Пример:

x = tf.constant([5, 4, 6])
y = tf.constant([5])
tf.math.less_equal(x, y) ==> [True, True, False]

x = tf.constant([5, 4, 6])
y = tf.constant([5, 6, 6])
tf.math.less_equal(x, y) ==> [True, True, True]

__len__

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

__len__()

__lt__

__lt__(
    x, y, name=None
)

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

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

Пример:

x = tf.constant([5, 4, 6])
y = tf.constant([5])
tf.math.less(x, y) ==> [False, True, False]

x = tf.constant([5, 4, 6])
y = tf.constant([5, 6, 7])
tf.math.less(x, y) ==> [False, True, True]

__matmul__

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

__matmul__(
    x, y
)

Умножает матрицу a на матрицу b, получая a * b.

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

Обе матрицы должны быть одного типа. Поддерживаемые типы: float16, float32, float64, int32, complex64, complex128.

Любую матрицу можно транспонировать или сопрячь и транспонировать на лету, установив соответствующий флаг в True. По умолчанию они равны False.

Если одна или обе матрицы содержат много нулей, можно использовать более эффективный алгоритм умножения, установив соответствующие флаги a_is_sparse или b_is_sparse в True. По умолчанию они равны False.

Оптимизация доступна только для обычных матриц (тензоры ранга 2) с типами данных bfloat16 или float32.

Простое умножение матриц 2-мерного тензора:

a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])
a  # 2-D tensor
<tf.Tensor: shape=(2, 3), dtype=int32, numpy=
array([[1, 2, 3],
       [4, 5, 6]], dtype=int32)>
b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])
b  # 2-D tensor
<tf.Tensor: shape=(3, 2), dtype=int32, numpy=
array([[ 7,  8],
       [ 9, 10],
       [11, 12]], dtype=int32)>
c = tf.matmul(a, b)
c  # `a` * `b`
<tf.Tensor: shape=(2, 2), dtype=int32, numpy=
array([[ 58,  64],
       [139, 154]], dtype=int32)>

Умножение матриц в пакете с формой пакета [2]:

a = tf.constant(np.arange(1, 13, dtype=np.int32), shape=[2, 2, 3])
a  # 3-D tensor
<tf.Tensor: shape=(2, 2, 3), dtype=int32, numpy=
array([[[ 1,  2,  3],
        [ 4,  5,  6]],
       [[ 7,  8,  9],
        [10, 11, 12]]], dtype=int32)>
b = tf.constant(np.arange(13, 25, dtype=np.int32), shape=[2, 3, 2])
b  # 3-D tensor
<tf.Tensor: shape=(2, 3, 2), dtype=int32, numpy=
array([[[13, 14],
        [15, 16],
        [17, 18]],
       [[19, 20],
        [21, 22],
        [23, 24]]], dtype=int32)>
c = tf.matmul(a, b)
c  # `a` * `b`
<tf.Tensor: shape=(2, 2, 2), dtype=int32, numpy=
array([[[ 94, 100],
        [229, 244]],
       [[508, 532],
        [697, 730]]], dtype=int32)>

Так как python >= 3.5 поддерживается оператор @ (см. PEP 465). В TensorFlow он просто вызывает функцию tf.matmul(), поэтому следующие строки эквивалентны:

d = a @ b @ [[10], [11]]
d = tf.matmul(tf.matmul(a, b), [[10], [11]])

__mod__

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

__mod__(
    x, y
)

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

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

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

__mul__

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

__mul__(
    x, y
)

Выполняет поэлементное умножение для "DenseDense" и "DenseSparse".

__ne__

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

__ne__(
    other
)

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

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

Цель в API:

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

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

__neg__

__neg__(
    x, name=None
)

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

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

__nonzero__

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

__nonzero__()

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

Это аналог Python 2.x для __bool__() выше.

__or__

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

__or__(
    x, y
)

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

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

__pow__

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

__pow__(
    x, y
)

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

Даны тензор 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, x
)

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

Цель в API:

This method is exposed in TensorFlow's API so that library developers
can register dispatching for <a href="../tf/Tensor#__add__"><code>Tensor.__add__</code></a> to allow it to handle
custom composite tensors & other custom objects.

The API symbol is not intended to be called by users directly and does
appear in TensorFlow's generated documentation.

__rand__

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

__rand__(
    y, x
)

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

Операция работает для следующих типов ввода:

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

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

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

c = tf.constant([True])
x = tf.constant([False, True, True, False])
tf.math.logical_and(c, x)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False,  True,  True, False])>

y = tf.constant([False, False, True, True])
z = tf.constant([False, True, False, True])
tf.math.logical_and(y, z)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False, False, False,  True])>

__rdiv__

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

__rdiv__(
    y, x
)

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

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

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

__rfloordiv__

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

__rfloordiv__(
    y, x
)

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

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

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

__rmatmul__

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

__rmatmul__(
    y, x
)

Умножает матрицу a на матрицу b, получая a * b.

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

Обе матрицы должны быть одного типа. Поддерживаемые типы: float16, float32, float64, int32, complex64, complex128.

Любая из матриц может быть транспонирована или сопряжена (с сопряжённым транспонированием) на лету, установив соответствующий флаг в True. По умолчанию они False.

Если одна или обе матрицы содержат много нулей, можно использовать более эффективный алгоритм умножения, установив соответствующий a_is_sparse или b_is_sparse флаг в значение True. По умолчанию они False. Эта оптимизация доступна только для обычных матриц (тензоров ранга 2) с типами данных bfloat16 или float32.

Простое умножение матриц 2-мерного тензора:

a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])
a  # 2-D tensor
<tf.Tensor: shape=(2, 3), dtype=int32, numpy=
array([[1, 2, 3],
       [4, 5, 6]], dtype=int32)>
b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])
b  # 2-D tensor
<tf.Tensor: shape=(3, 2), dtype=int32, numpy=
array([[ 7,  8],
       [ 9, 10],
       [11, 12]], dtype=int32)>
c = tf.matmul(a, b)
c  # `a` * `b`
<tf.Tensor: shape=(2, 2), dtype=int32, numpy=
array([[ 58,  64],
       [139, 154]], dtype=int32)>

Умножение матриц с пакетной формой [2]:

a = tf.constant(np.arange(1, 13, dtype=np.int32), shape=[2, 2, 3])
a  # 3-D tensor
<tf.Tensor: shape=(2, 2, 3), dtype=int32, numpy=
array([[[ 1,  2,  3],
        [ 4,  5,  6]],
       [[ 7,  8,  9],
        [10, 11, 12]]], dtype=int32)>
b = tf.constant(np.arange(13, 25, dtype=np.int32), shape=[2, 3, 2])
b  # 3-D tensor
<tf.Tensor: shape=(2, 3, 2), dtype=int32, numpy=
array([[[13, 14],
        [15, 16],
        [17, 18]],
       [[19, 20],
        [21, 22],
        [23, 24]]], dtype=int32)>
c = tf.matmul(a, b)
c  # `a` * `b`
<tf.Tensor: shape=(2, 2, 2), dtype=int32, numpy=
array([[[ 94, 100],
        [229, 244]],
       [[508, 532],
        [697, 730]]], dtype=int32)>

Так как в Python >= 3.5 поддерживается оператор @ (см. PEP 465). В TensorFlow он просто вызывает функцию tf.matmul(), поэтому следующие строки эквивалентны:

d = a @ b @ [[10], [11]]
d = tf.matmul(tf.matmul(a, b), [[10], [11]])

__rmod__

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

__rmod__(
    y, x
)

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

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

__rmul__

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

__rmul__(
    y, x
)

Выполняет поэлементное умножение для "DenseDense" и "DenseSparse".

__ror__

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

__ror__(
    y, x
)

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

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

__rpow__

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

__rpow__(
    y, x
)

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

Даны тензор 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, x
)

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

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

__rtruediv__

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

__rtruediv__(
    y, x
)

Делит 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, x
)

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

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

Операция работает для следующих типов входных данных:

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

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

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

c = tf.constant([True])
x = tf.constant([False, True, True, False])
tf.math.logical_xor(c, x)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([ True, False, False,  True])>

y = tf.constant([False, False, True, True])
z = tf.constant([False, True, False, True])
tf.math.logical_xor(y, z)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False,  True,  True, False])>

__sub__

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

__sub__(
    x, y
)

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

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

__truediv__

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

__truediv__(
    x, y
)

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

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

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

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

__xor__

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

__xor__(
    x, y
)

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

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

Операция работает со следующими типами входных данных:

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

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

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

c = tf.constant([True])
x = tf.constant([False, True, True, False])
tf.math.logical_xor(c, x)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([ True, False, False,  True])>

y = tf.constant([False, False, True, True])
z = tf.constant([False, True, False, True])
tf.math.logical_xor(y, z)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False,  True,  True, False])>

Переменные класса

• OVERLOADABLE_OPERATORS