tf.Tensor

A tf.Tensor представляет многомерный массив элементов.

tf.Tensor(
    op, value_index, dtype
)

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

При написании программы 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.

a = np.array([1, 2, 3])
b = tf.constant(a)
a[0] = 4
print(b)  # tf.Tensor([4 2 3], shape=(3,), dtype=int64)

Примечание: это деталь реализации, которая может измениться, и пользователи не должны полагаться на это поведение.

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

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

Методы

consumers

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

consumers()

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

eval

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

eval(
    feed_dict=None, session=None
)

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

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

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

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

experimental_ref

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

experimental_ref()

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

get_shape

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

get_shape()

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

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

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 никаких операций не выполняется, формы могут быть неизвестны (см. руководство по конкретным функциям Concrete Functions Guide для получения подробностей).

@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 обеспечивает лучшую проверку ошибок программирования и может создавать гарантии для оптимизации компилятора.

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

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

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

Цель в API:

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

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

__and__

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

__and__(
    y
)

__array__

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

__array__(
    dtype=None
)

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

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

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

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

__eq__

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

__eq__(
    other
)

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

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

Цель в API:

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

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

__floordiv__

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

__floordiv__(
    y
)

Делит 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__(
    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__(
    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__(
    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__(
    name=None
)

__iter__

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

__iter__()

__le__

__le__(
    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__(
    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__(
    y
)

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

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

Обе матрицы должны быть одного типа. Поддерживаемые типы: bfloat16, float16, float32, float64, int32, int64, 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__(
    y
)

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

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

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

__mul__

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

__mul__(
    y
)

Пересылает cwise mul для "DenseDense" и "DenseSparse".

__ne__

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

__ne__(
    other
)

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

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

Цель в API:

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

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

__neg__

__neg__(
    name=None
)

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

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

__nonzero__

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

__nonzero__()

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

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

__or__

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

__or__(
    y
)

__pow__

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

__pow__(
    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__(
    x
)

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

Цель в API:

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

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

__rand__

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

__rand__(
    x
)

__rdiv__

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

__rdiv__(
    x
)

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

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

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

__rfloordiv__

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

__rfloordiv__(
    x
)

Делит 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 должны иметь одинаковый тип, и результат также будет иметь тот же тип.

__rmatmul__

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

__rmatmul__(
    x
)

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

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

Обе матрицы должны быть одного типа. Поддерживаемые типы: bfloat16, float16, float32, float64, int32, int64, 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__(
    x
)

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

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

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

__rmul__

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

__rmul__(
    x
)

Передаёт cwise mul для "DenseDense" и "DenseSparse".

__ror__

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

__ror__(
    x
)

__rpow__

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

__rpow__(
    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__(
    x
)

Возвращает 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__(
    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__(
    x
)

__sub__

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

__sub__(
    y
)

Возвращает 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
)

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

{
 '__abs__',
 '__add__',
 '__and__',
 '__div__',
 '__eq__',
 '__floordiv__',
 '__ge__',
 '__getitem__',
 '__gt__',
 '__invert__',
 '__le__',
 '__lt__',
 '__matmul__',
 '__mod__',
 '__mul__',
 '__ne__',
 '__neg__',
 '__or__',
 '__pow__',
 '__radd__',
 '__rand__',
 '__rdiv__',
 '__rfloordiv__',
 '__rmatmul__',
 '__rmod__',
 '__rmul__',
 '__ror__',
 '__rpow__',
 '__rsub__',
 '__rtruediv__',
 '__rxor__',
 '__sub__',
 '__truediv__',
 '__xor__'
}