tf.contrib.eager.Variable

Переменная на основе дескрипторов ресурсов.

tf.contrib.eager.Variable(
    initial_value=None, trainable=None, collections=None, validate_shape=True,
    caching_device=None, name=None, dtype=None, variable_def=None,
    import_scope=None, constraint=None, distribute_strategy=None,
    synchronization=None, aggregation=None, shape=None
)

См. Руководство по переменным для общего обзора.

Переменная позволяет сохранять состояние между вызовами session.run.

Конструктор ResourceVariable требует начального значения для переменной, которое может быть тензором Tensor любого типа и формы. Начальное значение определяет тип и форму переменной. После построения тип и форма переменной фиксируются. Значение можно изменить, используя один из методов присваивания.

Как и любая Tensor, переменные, созданные с помощью tf.Variable(use_resource=True), могут использоваться в качестве входных данных для других операций в графе. Кроме того, все перегруженные операторы для класса Tensor переносятся на переменные, поэтому вы также можете добавлять узлы в граф, просто выполняя арифметические операции над переменными.

В отличие от переменной на основе ссылок, у ResourceVariable есть чётко определённая семантика. Каждое использование ResourceVariable в графе TensorFlow добавляет операцию read_value в граф. Тензоры, возвращаемые операцией read_value, гарантированно видят все изменения значения переменной, происходящие в любой операции, от которой зависит read_value (прямо, косвенно или через зависимость по управлению), и гарантированно не видят никаких изменений значения переменной от операций, которые зависят от операции read_value. Изменения от операций, не имеющих зависимостей от операции read_value, могут быть или не быть видны read_value.

Например, если в одном вызове session.run есть более одного присваивания ResourceVariable, для каждой операции, использующей значение переменной, существует чётко определённое значение, если присваивания и чтение соединены рёбрами в графе. Рассмотрим следующий пример, в котором два записи могут привести к тому, что tf.Variable и tf.ResourceVariable будут вести себя по-разному:

a = tf.Variable(1.0, use_resource=True)
a.initializer.run()

assign = a.assign(2.0)
with tf.control_dependencies([assign]):
  b = a.read_value()
with tf.control_dependencies([b]):
  other_assign = a.assign(3.0)
with tf.control_dependencies([other_assign]):
  # Will print 2.0 because the value was read before other_assign ran. If
  # `a` was a tf.Variable instead, 2.0 or 3.0 could be printed.
  tf.compat.v1.Print(b, [b]).eval()

Подклассы

class SaveSliceInfo

Методы

assign

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

assign(
    value, use_locking=None, name=None, read_value=True
)

Присваивает новое значение этой переменной.

assign_add

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

assign_add(
    delta, use_locking=None, name=None, read_value=True
)

Добавляет значение к этой переменной.

assign_sub

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

assign_sub(
    delta, use_locking=None, name=None, read_value=True
)

Вычитает значение из этой переменной.

batch_scatter_update

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

batch_scatter_update(
    sparse_delta, use_locking=False, name=None
)

Присваивает значения tf.IndexedSlices переменной поочерёдно.

Аналогично batch_gather. Предполагается, что у этой переменной и IndexedSlices sparse_delta есть серия ведущих измерений, которые одинаковы для всех из них, и обновления выполняются по последнему измерению индексов. Другими словами, размеры должны быть следующими:

num_prefix_dims = sparse_delta.indices.ndims - 1 batch_dim = num_prefix_dims + 1 sparse_delta.updates.shape = sparse_delta.indices.shape + var.shape[ batch_dim:]

где

sparse_delta.updates.shape[:num_prefix_dims] == sparse_delta.indices.shape[:num_prefix_dims] == var.shape[:num_prefix_dims]

И выполняемая операция может быть выражена как:

var[i_1, ..., i_n, sparse_delta.indices[i_1, ..., i_n, j]] = sparse_delta.updates[ i_1, ..., i_n, j]

Когда sparse_delta.indices является тензором 1D, эта операция эквивалентна scatter_update.

Чтобы избежать этой операции, можно перебрать первые ndims переменной и использовать scatter_update на подтензорах, которые являются результатом среза первого измерения. Это допустимый вариант для ndims = 1, но менее эффективен, чем данная реализация.

count_up_to

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

count_up_to(
    limit
)

Увеличивает переменную, пока она не достигнет значения limit. (устарело)

При выполнении этой операции она пытается увеличить переменную на 1. Если увеличение переменной приведёт к значению большему, чем limit, операция вызывает исключение OutOfRangeError.

Если ошибка не возникнет, операция выводит значение переменной до увеличения.

Это по сути сокращение для count_up_to(self, limit).

eval

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

eval(
    session=None
)

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

experimental_ref

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

experimental_ref()

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

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

import tensorflow as tf

x = tf.Variable(5)
y = tf.Variable(10)
z = tf.Variable(10)

# The followings will raise an exception starting 2.0
# TypeError: Variable is unhashable if Variable equality is enabled.
variable_set = {x, y, z}
variable_dict = {x: 'five', y: 'ten'}

Вместо этого можно использовать variable.experimental_ref().

variable_set = {x.experimental_ref(),
                y.experimental_ref(),
                z.experimental_ref()}

print(x.experimental_ref() in variable_set)
==> True

variable_dict = {x.experimental_ref(): 'five',
                 y.experimental_ref(): 'ten',
                 z.experimental_ref(): 'ten'}

print(variable_dict[y.experimental_ref()])
==> ten

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

x = tf.Variable(5)
print(x.experimental_ref().deref())
==> <tf.Variable 'Variable:0' shape=() dtype=int32, numpy=5>

from_proto

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

@staticmethod
from_proto(
    variable_def, import_scope=None
)

Возвращает объект Variable, созданный из variable_def.

gather_nd

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

gather_nd(
    indices, name=None
)

Читает значение этой переменной в виде разреженных данных, используя gather_nd.

get_shape

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

get_shape()

Псевдоним для Variable.shape.

initialized_value

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

initialized_value()

Возвращает значение инициализированной переменной. (устарело)

Используйте её вместо самой переменной для инициализации другой переменной со значением, зависящим от значения этой переменной.

# Initialize 'v' with a random tensor.
v = tf.Variable(tf.random.truncated_normal([10, 40]))
# Use `initialized_value` to guarantee that `v` has been
# initialized before its value is used to initialize `w`.
# The random values are picked only once.
w = tf.Variable(v.initialized_value() * 2.0)

is_initialized

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

is_initialized(
    name=None
)

Проверяет, была ли инициализирована переменная ресурса.

Выводит булево скалярное значение, указывающее, была ли тензор инициализирован.

load

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

load(
    value, session=None
)

Загрузка нового значения в эту переменную. (устарело)

Записывает новое значение в память переменной. Не добавляет операции в граф.

Этот удобный метод требует сессии, где граф, содержащий эту переменную, запущен. Если сессия не передана, используется стандартная сессия. См. tf.compat.v1.Session для получения дополнительной информации о запуске графа и сессиях.

v = tf.Variable([1, 2])
init = tf.compat.v1.global_variables_initializer()

with tf.compat.v1.Session() as sess:
    sess.run(init)
    # Usage passing the session explicitly.
    v.load([2, 3], sess)
    print(v.eval(sess)) # prints [2 3]
    # Usage with the default session.  The 'with' block
    # above makes 'sess' the default session.
    v.load([3, 4], sess)
    print(v.eval()) # prints [3 4]

numpy

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

numpy()

read_value

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

read_value()

Создаёт операцию, которая считывает значение этой переменной.

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

scatter_add

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

scatter_add(
    sparse_delta, use_locking=False, name=None
)

Добавляет tf.IndexedSlices к этой переменной.

scatter_div

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

scatter_div(
    sparse_delta, use_locking=False, name=None
)

Делит эту переменную на tf.IndexedSlices.

scatter_max

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

scatter_max(
    sparse_delta, use_locking=False, name=None
)

Обновляет эту переменную максимальным значением из tf.IndexedSlices и её текущего значения.

scatter_min

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

scatter_min(
    sparse_delta, use_locking=False, name=None
)

Обновляет эту переменную минимальным значением из tf.IndexedSlices и её текущего значения.

scatter_mul

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

scatter_mul(
    sparse_delta, use_locking=False, name=None
)

Умножает эту переменную на tf.IndexedSlices.

scatter_nd_add

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

scatter_nd_add(
    indices, updates, name=None
)

Применяет разбросанное сложение к отдельным значениям или срезам в переменной.

ref — это Tensor с рангом P, а indices — это Tensor ранга Q.

indices должно быть целочисленным тензором, содержащим индексы в ref. Его форма должна быть [d_0, ..., d_{Q-2}, K], где 0 < K <= P.

Внутреннее измерение indices (длиной K) соответствует индексам к элементам (если K = P) или срезам (если K < P) вдоль K-го измерения ref.

updates — это Tensor ранга Q-1+P-K с формой:

[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].

Например, скажем, мы хотим добавить 4 разбросанных элемента к тензору ранга 1 к 8 элементам. На Python этот обновление будет выглядеть так:

ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
indices = tf.constant([[4], [3], [1] ,[7]])
updates = tf.constant([9, 10, 11, 12])
add = ref.scatter_nd_add(indices, updates)
with tf.compat.v1.Session() as sess:
  print sess.run(add)

Результат обновления ref будет таким:

[1, 13, 3, 14, 14, 6, 7, 20]

См. tf.scatter_nd для получения более подробной информации о том, как выполнять обновления срезов.

scatter_nd_sub

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

scatter_nd_sub(
    indices, updates, name=None
)

Применяет разбросанное вычитание к отдельным значениям или срезам в переменной.

ref — это Tensor с рангом P, а indices — это Tensor ранга Q.

indices должно быть целочисленным тензором, содержащим индексы в ref. Его форма должна быть [d_0, ..., d_{Q-2}, K], где 0 < K <= P.

Внутреннее измерение indices (длиной K) соответствует индексам к элементам (если K = P) или срезам (если K < P) вдоль K-го измерения ref.

updates — это Tensor ранга Q-1+P-K с формой:

[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].

Например, скажем, мы хотим добавить 4 разбросанных элемента к тензору ранга 1 к 8 элементам. На Python этот обновление будет выглядеть так:

ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
indices = tf.constant([[4], [3], [1] ,[7]])
updates = tf.constant([9, 10, 11, 12])
op = ref.scatter_nd_sub(indices, updates)
with tf.compat.v1.Session() as sess:
  print sess.run(op)

Результат обновления ref будет таким:

[1, -9, 3, -6, -6, 6, 7, -4]

См. tf.scatter_nd для получения более подробной информации о том, как выполнять обновления срезов.

scatter_nd_update

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

scatter_nd_update(
    indices, updates, name=None
)

Применяет разреженное присваивание к отдельным значениям или срезам в переменной.

ref — это Tensor с рангом P, а indices — это Tensor ранга Q.

indices должно быть целочисленным тензором, содержащим индексы в ref. Его форма должна быть [d_0, ..., d_{Q-2}, K], где 0 < K <= P.

Наивнутренний размер indices (длиной K) соответствует индексам элементов (если K = P) или срезов (если K < P) вдоль K-го измерения ref.

updates — это Tensor ранга Q-1+P-K с формой:

[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].

Например, предположим, что мы хотим добавить 4 рассеянных элемента к тензору ранга-1 к 8 элементам. В Python это обновление будет выглядеть так:

ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
indices = tf.constant([[4], [3], [1] ,[7]])
updates = tf.constant([9, 10, 11, 12])
op = ref.scatter_nd_update(indices, updates)
with tf.compat.v1.Session() as sess:
  print sess.run(op)

Результирующее обновление ref будет выглядеть так:

[1, 11, 3, 10, 9, 6, 7, 12]

См. tf.scatter_nd для получения более подробной информации о способах обновления срезов.

scatter_sub

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

scatter_sub(
    sparse_delta, use_locking=False, name=None
)

Вычитает tf.IndexedSlices из этой переменной.

scatter_update

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

scatter_update(
    sparse_delta, use_locking=False, name=None
)

Присваивает tf.IndexedSlices этой переменной.

set_shape

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

set_shape(
    shape
)

Не поддерживается.

sparse_read

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

sparse_read(
    indices, name=None
)

Считывает значение этой переменной разреженно, используя gather.

to_proto

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

to_proto(
    export_scope=None
)

Преобразует ResourceVariable в протокольный буфер VariableDef.

value

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

value()

Кэшированная операция, которая считывает значение этой переменной.

__abs__

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

__abs__(
    x, name=None
)

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

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

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

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

__add__

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

__add__(
    x, y
)

Перенаправляет на add для строк и add_v2 для всех других типов.

__and__

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

__and__(
    x, y
)

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

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

__bool__

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

__bool__()

__div__

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

__div__(
    x, y
)

Делит два значения с использованием семантики Python 2.

Используется для Tensor.div.

__eq__

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

__eq__(
    other
)

Сравнивает два объекта переменных попарно на равенство.

__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 поддерживает векторизацию. Подробнее о векторизации здесь

__getitem__

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

__getitem__(
    var, slice_spec
)

Создаёт объект помощника среза для заданной переменной.

Это позволяет создавать подтензор из части текущего содержимого переменной. Подробнее о срезах см. в tf.Tensor.getitem.

Эта функция также позволяет присваивать значения срезу. Это аналогично функции __setitem__ в Python. Однако синтаксис отличается, чтобы пользователь мог захватить операцию присвоения для группировки или передачи в sess.run(). Например,

import tensorflow as tf
A = tf.Variable([[1,2,3], [4,5,6], [7,8,9]], dtype=tf.float32)
with tf.compat.v1.Session() as sess:
  sess.run(tf.compat.v1.global_variables_initializer())
  print(sess.run(A[:2, :2]))  # => [[1,2], [4,5]]

  op = A[:2,:2].assign(22. * tf.ones((2, 2)))
  print(sess.run(op))  # => [[22, 22, 3], [22, 22, 6], [7,8,9]]

Обратите внимание, что присвоения в настоящее время не поддерживают семантику векторизации NumPy.

__gt__

__gt__(
    x, y, name=None
)

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

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

__invert__

__invert__(
    x, name=None
)

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

__iter__

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

__iter__()

Метод-заглушка для предотвращения итерации.

Не вызывать.

ПРИМЕЧАНИЕ(mrry): Если мы регистрируем getitem как перегруженный оператор, Python попытается итерироваться по тензору переменной от 0 до бесконечности. Объявление этого метода предотвращает это непреднамеренное поведение.

__le__

__le__(
    x, y, name=None
)

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

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

__lt__

__lt__(
    x, y, name=None
)

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

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

__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 tensor `a`
# [[1, 2, 3],
#  [4, 5, 6]]
a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])

# 2-D tensor `b`
# [[ 7,  8],
#  [ 9, 10],
#  [11, 12]]
b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])

# `a` * `b`
# [[ 58,  64],
#  [139, 154]]
c = tf.matmul(a, b)


# 3-D tensor `a`
# [[[ 1,  2,  3],
#   [ 4,  5,  6]],
#  [[ 7,  8,  9],
#   [10, 11, 12]]]
a = tf.constant(np.arange(1, 13, dtype=np.int32),
                shape=[2, 2, 3])

# 3-D tensor `b`
# [[[13, 14],
#   [15, 16],
#   [17, 18]],
#  [[19, 20],
#   [21, 22],
#   [23, 24]]]
b = tf.constant(np.arange(13, 25, dtype=np.int32),
                shape=[2, 3, 2])

# `a` * `b`
# [[[ 94, 100],
#   [229, 244]],
#  [[508, 532],
#   [697, 730]]]
c = tf.matmul(a, b)

# Since python >= 3.5 the @ operator is supported (see PEP 465).
# In TensorFlow, it simply calls the `tf.matmul()` function, so the
# following lines are equivalent:
d = a @ b @ [[10.], [11.]]
d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])

__mod__

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

__mod__(
    x, y
)

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

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

__mul__

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

__mul__(
    x, y
)

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

__ne__

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

__ne__(
    other
)

Сравнивает два переменные поэлементно на равенство.

__neg__

__neg__(
    x, name=None
)

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

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

__nonzero__

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

__nonzero__()

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

Вызывает add для строк и add_v2 для всех других типов.

__rand__

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

__rand__(
    y, x
)

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

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

__rdiv__

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

__rdiv__(
    y, x
)

Делит два значения, используя семантику Python 2.

Используется для Tensor.div.

__rfloordiv__

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

__rfloordiv__(
    y, x
)

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

То же самое, что и 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-D tensor `a`
# [[1, 2, 3],
#  [4, 5, 6]]
a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])

# 2-D tensor `b`
# [[ 7,  8],
#  [ 9, 10],
#  [11, 12]]
b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])

# `a` * `b`
# [[ 58,  64],
#  [139, 154]]
c = tf.matmul(a, b)


# 3-D tensor `a`
# [[[ 1,  2,  3],
#   [ 4,  5,  6]],
#  [[ 7,  8,  9],
#   [10, 11, 12]]]
a = tf.constant(np.arange(1, 13, dtype=np.int32),
                shape=[2, 2, 3])

# 3-D tensor `b`
# [[[13, 14],
#   [15, 16],
#   [17, 18]],
#  [[19, 20],
#   [21, 22],
#   [23, 24]]]
b = tf.constant(np.arange(13, 25, dtype=np.int32),
                shape=[2, 3, 2])

# `a` * `b`
# [[[ 94, 100],
#   [229, 244]],
#  [[508, 532],
#   [697, 730]]]
c = tf.matmul(a, b)

# Since python >= 3.5 the @ operator is supported (see PEP 465).
# In TensorFlow, it simply calls the `tf.matmul()` function, so the
# following lines are equivalent:
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
)

Возвращает логическое значение x OR 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
)

__rxor__

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

__rxor__(
    y, x
)

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

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

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

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

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

__sub__

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

__sub__(
    x, y
)

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

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

__truediv__

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

__truediv__(
    x, y
)

__xor__

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

__xor__(
    x, y
)

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

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

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

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

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