tf.compat.v1.Variable

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

Наследуется от: Variable

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

Переменная сохраняет состояние в графе между вызовами run(). Вы добавляете переменную в граф, создавая экземпляр класса Variable.

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

Если вы хотите изменить форму переменной позже, вам нужно использовать операцию assign с validate_shape=False.

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

import tensorflow as tf

# Create a variable.
w = tf.Variable(<initial-value>, name=<optional-name>)

# Use the variable in the graph like any Tensor.
y = tf.matmul(w, ...another variable or tensor...)

# The overloaded operators are available too.
z = tf.sigmoid(w + y)

# Assign a new value to the variable with `assign()` or a related method.
w.assign(w + 1.0)
w.assign_add(1.0)

При запуске графа переменные должны быть явно инициализированы, прежде чем вы сможете запустить операции, использующие их значения. Вы можете инициализировать переменную, выполнив её оператор инициализации, восстановив переменную из файла сохранения или просто выполнив операцию assign , которая присваивает значение переменной. Фактически, оператор инициализации переменной - это просто операция assign , которая присваивает начальное значение переменной самой переменной.

# Launch the graph in a session.
with tf.compat.v1.Session() as sess:
    # Run the variable initializer.
    sess.run(w.initializer)
    # ...you now can run ops that use the value of 'w'...

Самый распространённый шаблон инициализации - использование удобной функции global_variables_initializer() для добавления операции в граф, которая инициализирует все переменные. Затем вы запускаете эту операцию после запуска графа.

# Add an Op to initialize global variables.
init_op = tf.compat.v1.global_variables_initializer()

# Launch the graph in a session.
with tf.compat.v1.Session() as sess:
    # Run the Op that initializes global variables.
    sess.run(init_op)
    # ...you can now run any Op that uses variable values...

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

Все переменные автоматически собираются в графе, где они созданы. По умолчанию конструктор добавляет новую переменную в коллекцию графа GraphKeys.GLOBAL_VARIABLES. Удобная функция global_variables() возвращает содержимое этой коллекции.

При построении модели машинного обучения часто удобно различать переменные, хранящие обучаемые параметры модели, и другие переменные, такие как переменная global step , используемая для подсчёта шагов обучения. Для упрощения этого конструктор переменной поддерживает параметр trainable=<bool>. Если True, новая переменная также добавляется в коллекцию графа GraphKeys.TRAINABLE_VARIABLES. Удобная функция trainable_variables() возвращает содержимое этой коллекции. Различные классы Optimizer используют эту коллекцию в качестве списка переменных по умолчанию для оптимизации.

v = tf.Variable(True)
tf.cond(v, lambda: v.assign(False), my_false_fn)  # Note: this is broken.

Здесь добавление use_resource=True при создании переменной устранит любые проблемы с непредсказуемостью:

v = tf.Variable(True, use_resource=True)
tf.cond(v, lambda: v.assign(False), my_false_fn)

Чтобы использовать замену для переменных, у которых нет этих проблем:

• Добавьте use_resource=True при создании tf.Variable;
• Вызовите tf.compat.v1.get_variable_scope().set_use_resource(True) внутри tf.compat.v1.variable_scope перед вызовом tf.compat.v1.get_variable().

Дочерние классы

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 является 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
)

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

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

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

Извлекает фрагменты из params по оси 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). (устарело)

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

Описание

Эта функция делит x и y, принуждая использовать семантику Python 2. То есть, если x и y являются целыми числами, то результат будет целым числом. Это отличается от 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 или 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). (устарело)

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

Описание

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

__rfloordiv__

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

__rfloordiv__(
    x
)

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

Математически это эквивалентно floor(x / y). Например: floor(8.4 / 4.0) = floor(2.1) = 2.0 floor(-8.4 / 4.0) = floor(-2.1) = -3.0 Это эквивалентно оператору '//' в Python 3.0 и выше.

Примечание: x и y должны иметь один и тот же тип, и результат также будет иметь тот же тип.

__rmatmul__

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

__rmatmul__(
    x
)

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

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

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

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

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

Простое умножение матриц 2-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__(
    x
)

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

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

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

__rmul__

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

__rmul__(
    x
)

Выполняет поэлементное умножение для "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).

Примечание: Предпочтительнее использовать оператор 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).

__xor__

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

__xor__(
    y
)