tf.Tensor

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

tf.Tensor(
    op, value_index, dtype
)

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

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

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

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

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

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

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

Возвращает список операций, которые используют этот тензор.

eval

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

eval(
    feed_dict=None, session=None
)

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

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

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

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

experimental_ref

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

experimental_ref()

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

get_shape

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

get_shape()

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

В режиме eager execution форма всегда полностью известна.

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

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

@tf.function
def my_fun(a):
  a = tf.ensure_shape(a, [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
)

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

Примечание: Рекомендуется использовать tf.ensure_shape вместо Tensor.set_shape, так как tf.ensure_shape обеспечивает лучшую проверку ошибок программирования и может создавать гарантии для оптимизации компилятора.

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

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}\).

Например:

# real number
x = tf.constant([-2.25, 3.25])
tf.abs(x)
<tf.Tensor: shape=(2,), dtype=float32,
numpy=array([2.25, 3.25], dtype=float32)>

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

__add__

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

__add__(
    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__

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

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

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

__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-D:

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
)

Отправляет cwise mul для "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
)

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

__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)) для аргументов с плавающей точкой, чтобы результат всегда был целым числом (хотя, возможно, целое число, представленное как число с плавающей точкой). Эта операция генерируется оператором целочисленного деления с округлением вниз в 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 xor y < 0 верно, это соответствует семантике Python, в том смысле, что результат здесь согласуется с целочисленным делением с округлением вниз. Например, floor(x / y) * y + mod(x, y) = x.

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

__rmul__

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

__rmul__(
    y, x
)

Вызывает cwise mul для "DenseDense" и "DenseSparse".

__ror__

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

__ror__(
    y, x
)

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

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