tf.Variable

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

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

tf.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.VariableAggregation.NONE, shape=None
)

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

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

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

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

count_up_to

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

count_up_to(
    limit
)

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

При выполнении этого оператора (Op) он пытается увеличить переменную на 1. Если увеличение переменной приведет к значению, превышающему limit, то оператор (Op) вызывает исключение OutOfRangeError.

Если исключение не вызывается, оператор (Op) выводит значение переменной до увеличения.

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

data-text="eval" id="eval" tabindex="0">eval

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

eval(
    session=None
)

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

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

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

data-text="experimental_ref" id="experimental_ref" tabindex="0">experimental_ref

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

experimental_ref()

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

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

import tensorflow as tf

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

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

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

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

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

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

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

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

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

data-text="from_proto" id="from_proto" tabindex="0">from_proto

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

@staticmethod
from_proto(
    variable_def, import_scope=None
)

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

data-text="gather_nd" id="gather_nd" tabindex="0">gather_nd

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

gather_nd(
    indices, name=None
)

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

См. tf.gather_nd для получения подробностей.

data-text="get_shape" id="get_shape" tabindex="0">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(), если оно находится на другом устройстве, с зависимостями от управления и т. д.

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 этот update будет выглядеть так:

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) по 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])
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) по 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])
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
)

Извлекает срезы из параметров по оси 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
)

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

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

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

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

__add__

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

__add__(
    x, y
)

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

__and__

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

__and__(
    x, y
)

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

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

__div__

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

__div__(
    x, y
)

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

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

__eq__

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

__eq__(
    other
)

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

__floordiv__

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

__floordiv__(
    x, y
)

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

То же, что и tf.compat.v1.div(x,y) для целых чисел, но использует tf.floor(tf.compat.v1.div(x,y)) для чисел с плавающей запятой, чтобы результат всегда был целым числом (хотя возможно целым числом, представленным в виде числа с плавающей запятой). Эта операция генерируется x // y операцией целочисленного деления в Python 3 и в Python 2.7 с from __future__ import division.

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

__ge__

__ge__(
    x, y, name=None
)

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

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

__getitem__

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

__getitem__(
    var, slice_spec
)

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

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

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

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

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

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

__gt__

__gt__(
    x, y, name=None
)

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

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

__invert__

__invert__(
    x, name=None
)

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

__iter__

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

__iter__()

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

Не вызывать.

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

__le__

__le__(
    x, y, name=None
)

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

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

__lt__

__lt__(
    x, y, name=None
)

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

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

__matmul__

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

__matmul__(
    x, y
)

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

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

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

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

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

Например:

# 2-D tensor `a`
# [[1, 2, 3],
#  [4, 5, 6]]
a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])

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

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


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

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

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

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

__mod__

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

__mod__(
    x, y
)

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

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

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

__mul__

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

__mul__(
    x, y
)

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

__ne__

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

__ne__(
    other
)

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

__neg__

__neg__(
    x, name=None
)

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

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

__or__

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

__or__(
    x, y
)

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

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

__pow__

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

__pow__(
    x, y
)

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

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

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

__radd__

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

__radd__(
    y, x
)

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

__rand__

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

__rand__(
    y, x
)

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

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

__rdiv__

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

__rdiv__(
    y, x
)

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

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

__rfloordiv__

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

__rfloordiv__(
    y, x
)

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

__rmatmul__

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

__rmatmul__(
    y, x
)

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

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

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

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

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

Например:

# 2-D tensor `a`
# [[1, 2, 3],
#  [4, 5, 6]]
a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])

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

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


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

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

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

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

__rmod__

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

__rmod__(
    y, x
)

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

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

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

__rmul__

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

__rmul__(
    y, x
)

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

__ror__

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

__ror__(
    y, x
)

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

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

__rpow__

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

__rpow__(
    y, x
)

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

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

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

__rsub__

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

__rsub__(
    y, x
)

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

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

__rtruediv__

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

__rtruediv__(
    y, x
)

__rxor__

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

__rxor__(
    y, x
)

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

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

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

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

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

__sub__

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

__sub__(
    x, y
)

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

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

__truediv__

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

__truediv__(
    x, y
)

__xor__

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

__xor__(
    x, y
)

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

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

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

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

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