tf.Variable

См. руководство по переменным.

tf.Variable(
    initial_value=None,
    trainable=None,
    validate_shape=True,
    caching_device=None,
    name=None,
    variable_def=None,
    dtype=None,
    import_scope=None,
    constraint=None,
    synchronization=tf.VariableSynchronization.AUTO,
    aggregation=tf.compat.v1.VariableAggregation.NONE,
    shape=None
)

Переменная поддерживает общие, постоянные состояния, управляемые программой.

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

v = tf.Variable(1.)
v.assign(2.)
<tf.Variable ... shape=() dtype=float32, numpy=2.0>
v.assign_add(0.5)
<tf.Variable ... shape=() dtype=float32, numpy=2.5>

Аргумент shape в конструкторе Variable позволяет создавать переменную с менее определённой формой, чем её initial_value:

v = tf.Variable(1., shape=tf.TensorShape(None))
v.assign([[1.]])
<tf.Variable ... shape=<unknown> dtype=float32, numpy=array([[1.]], ...)>

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

w = tf.Variable([[1.], [2.]])
x = tf.constant([[3., 4.]])
tf.matmul(w, x)
<tf.Tensor:... shape=(2, 2), ... numpy=
  array([[3., 4.],
         [6., 8.]], dtype=float32)>
tf.sigmoid(w + x)
<tf.Tensor:... shape=(2, 2), ...>

При построении модели машинного обучения часто удобно различать переменные, хранящие обучаемые параметры модели, и другие переменные, такие как step переменная, используемая для подсчёта шагов обучения. Чтобы упростить это, конструктор переменной поддерживает параметр trainable=<bool>. tf.GradientTape по умолчанию отслеживает обучаемые переменные:

with tf.GradientTape(persistent=True) as tape:
  trainable = tf.Variable(1.)
  non_trainable = tf.Variable(2., trainable=False)
  x1 = trainable * 2.
  x2 = non_trainable * 3.
tape.gradient(x1, trainable)
<tf.Tensor:... shape=(), dtype=float32, numpy=2.0>
assert tape.gradient(x2, non_trainable) is None  # Unwatched

Переменные автоматически отслеживаются при присваивании атрибутам типов, наследующих от tf.Module.

m = tf.Module()
m.v = tf.Variable([1.])
m.trainable_variables
(<tf.Variable ... shape=(1,) ... numpy=array([1.], dtype=float32)>,)

Это отслеживание позволяет сохранять значения переменных в точках сохранения обучения или в SavedModels, которые включают сериализованные графы TensorFlow.

Переменные часто захватываются и обрабатываются tf.functionи. Это работает так же, как и незадекорированная функция:

v = tf.Variable(0.)
read_and_decrement = tf.function(lambda: v.assign_sub(0.1))
read_and_decrement()
<tf.Tensor: shape=(), dtype=float32, numpy=-0.1>
read_and_decrement()
<tf.Tensor: shape=(), dtype=float32, numpy=-0.2>

Переменные, созданные внутри tf.function, должны быть собственностью вне функции и созданы только один раз:

class M(tf.Module):
  @tf.function
  def __call__(self, x):
    if not hasattr(self, "v"):  # Or set self.v to None in __init__
      self.v = tf.Variable(x)
    return self.v * x
m = M()
m(2.)
<tf.Tensor: shape=(), dtype=float32, numpy=4.0>
m(3.)
<tf.Tensor: shape=(), dtype=float32, numpy=6.0>
m.v
<tf.Variable ... shape=() dtype=float32, numpy=2.0>

См. документацию tf.function для получения подробностей.

Подклассы

class SaveSliceInfo

Методы

assign

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

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

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

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

assign_add

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

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

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

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

assign_sub

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

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

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

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

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 — это одномерный тензор, эта операция эквивалентна 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
)

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

Это не метод построения графа, он не добавляет операции в граф.

Этот метод удобства требует сессии, где запущен граф, содержащий эту переменную. Если сессия не передана, используется стандартная сессия. См. 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.
    print(v.eval(sess))
    # Usage with the default session.  The 'with' block
    # above makes 'sess' the default session.
    print(v.eval())

experimental_ref

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

experimental_ref()

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

from_proto

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

@staticmethod
from_proto(
    variable_def, import_scope=None
)

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

gather_nd

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

gather_nd(
    indices, name=None
)

Извлекает срезы из params в тензор с формой, заданной indices.

См. tf.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)

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]

read_value

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

read_value()

Возвращает значение этой переменной, считанное в текущем контексте.

Может отличаться от value(), если она находится на другом устройстве, с зависимостями управления и т. п.

ref

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

ref()

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

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

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

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

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

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

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

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

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

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

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
)

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

Переменная имеет ранг P и indices — это Tensor ранга Q.

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

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

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

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

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

v = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
indices = tf.constant([[4], [3], [1] ,[7]])
updates = tf.constant([9, 10, 11, 12])
v.scatter_nd_add(indices, updates)
print(v)

Результат обновления v выглядел бы так:

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

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

scatter_nd_sub

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

scatter_nd_sub(
    indices, updates, name=None
)

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

Предполагается, что переменная имеет ранг P и indices является Tensor ранга Q.

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

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

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

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

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

v = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
indices = tf.constant([[4], [3], [1] ,[7]])
updates = tf.constant([9, 10, 11, 12])
v.scatter_nd_sub(indices, updates)
print(v)

После обновления v выглядело бы так:

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

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

scatter_nd_update

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

scatter_nd_update(
    indices, updates, name=None
)

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

Переменная имеет ранг P и indices является Tensor ранга Q.

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

Внутреннее измерение indices (длиной K) соответствует индексам элементов (если K = P) или срезов (если K < P) по K-му измерению self.

updates является Tensor ранга Q-1+P-K с формой:

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

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

v = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
indices = tf.constant([[4], [3], [1] ,[7]])
updates = tf.constant([9, 10, 11, 12])
v.scatter_nd_update(indices, updates)
print(v)

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

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

Сбор срезов из параметров по оси axis в соответствии с индексами.

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

to_proto

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

to_proto(
    export_scope=None
)

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

value

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

value()

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

Обычно вам не нужно вызывать этот метод, так как все операции, которым нужно значение переменной, вызывают его автоматически через вызов convert_to_tensor().

Возвращает Tensor, содержащий значение переменной. Вы не можете присвоить новое значение этому тензору, так как это не ссылка на переменную.

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

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

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

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

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

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

Это позволяет создать под-тензор из части текущего содержимого переменной. Смотрите 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__(
    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__()

При выполнении в режиме eager, итерирует по значению переменной.

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

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

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

__mul__

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

__mul__(
    y
)

Отправляет cwise mul для "DenseDense" и "DenseSparse".

__ne__

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

__ne__(
    other
)

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

__neg__

__neg__(
    name=None
)

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

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

__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. По умолчанию они b_is_sparse.

Если одна или обе матрицы содержат много нулей, можно использовать более эффективный алгоритм умножения, установив соответствующий флаг 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).

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

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

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

__rxor__

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

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