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), ...>

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

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) по %%%CODE_BLOCK_266%%-му измерению 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])
add = v.scatter_nd_add(indices, updates)
with tf.compat.v1.Session() as sess:
  print sess.run(add)

Результат обновления 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) по %%%CODE_BLOCK_290%%-му измерению 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])
op = v.scatter_nd_sub(indices, updates)
with tf.compat.v1.Session() as sess:
  print sess.run(op)

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

[1, -9, 3, -6, -6, 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) по %%%CODE_BLOCK_314%%-му измерению 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])
op = v.scatter_nd_assign(indices, updates)
with tf.compat.v1.Session() as sess:
  print sess.run(op)

Результат обновления 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
)

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

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

to_proto

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

to_proto(
    export_scope=None
)

Преобразует Variable в протокол VariableDef.

value

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

value()

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

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

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

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

__abs__

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

__abs__(
    x, name=None
)

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

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

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

• b^2}\).

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

__add__

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

__add__(
    x, y
)

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

Назначение в API:

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

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

__and__

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

__and__(
    x, y
)

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

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

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

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

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

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

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

__div__

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

__div__(
    x, y
)

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

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

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

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

Пример:

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

Пример:

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

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

__invert__

__invert__(
    x, name=None
)

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

Пример:

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

__iter__

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

__iter__()

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

Не вызывать.

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

__le__

__le__(
    x, y, name=None
)

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

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

Пример:

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

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

__lt__

__lt__(
    x, y, name=None
)

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

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

Пример:

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

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

__matmul__

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

__matmul__(
    x, y
)

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

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

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

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

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

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

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

Матричное умножение пакета с формой пакета [2]:

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

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

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

__mod__

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

__mod__(
    x, y
)

Возвращает остаток от целочисленного деления по элементам. Когда x < 0 или 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\).

__or__

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

__or__(
    x, y
)

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

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

__pow__

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

__pow__(
    x, y
)

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

Учитывая тензор x и тензор y, эта операция вычисляет \(x^y\) для соответствующих элементов в x и y. Например:

x = tf.constant([[2, 2], [3, 3]])
y = tf.constant([[8, 16], [2, 3]])
tf.pow(x, y)  # [[256, 65536], [9, 27]]

__radd__

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

__radd__(
    y, x
)

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

Цель в API:

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

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

__rand__

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

__rand__(
    y, x
)

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

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

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

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

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

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

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

__rdiv__

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

__rdiv__(
    y, x
)

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

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

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

__rfloordiv__

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

__rfloordiv__(
    y, x
)

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

То же, что и tf.compat.v1.div(x,y) для целых чисел, но использует округление к меньшему целому для аргументов с плавающей точкой, чтобы результат всегда был целым числом (возможно, целое число, представленное числом с плавающей точкой). Эта операция генерируется операцией целочисленного деления с округлением к меньшему в 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:

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

Матричное умножение пакета с формой пакета [2]:

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

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

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

__rmod__

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

__rmod__(
    y, x
)

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

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

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

__rmul__

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

__rmul__(
    y, x
)

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

__ror__

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

__ror__(
    y, x
)

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

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

__rpow__

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

__rpow__(
    y, x
)

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

Для тензора x и тензора y, эта операция вычисляет \(x^y\) для соответствующих элементов в x и y. Например:

x = tf.constant([[2, 2], [3, 3]])
y = tf.constant([[8, 16], [2, 3]])
tf.pow(x, y)  # [[256, 65536], [9, 27]]

__rsub__

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

__rsub__(
    y, x
)

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

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

__rtruediv__

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

__rtruediv__(
    y, x
)

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

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

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

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

__rxor__

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

__rxor__(
    y, x
)

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

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

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

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

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

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

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

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

__sub__

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

__sub__(
    x, y
)

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

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

__truediv__

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

__truediv__(
    x, y
)

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

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

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

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

__xor__

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

__xor__(
    x, y
)

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

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

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

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

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

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

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

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