tf.Variable

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

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

Переменная сохраняет общие, постоянные состояния, изменяемые программой.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Подклассы

class SaveSliceInfo

Методы

assign

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

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

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

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

assign_add

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

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

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

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

assign_sub

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

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

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

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

batch_scatter_update

View source

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

Assigns tf.IndexedSlices to this variable batch-wise.

Analogous to batch_gather. This assumes that this variable and the sparse_delta IndexedSlices have a series of leading dimensions that are the same for all of them, and the updates are performed on the last dimension of indices. In other words, the dimensions should be the following:

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

where

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

And the operation performed can be expressed as:

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

When sparse_delta.indices is a 1D tensor, this operation is equivalent to scatter_update.

To avoid this operation one can looping over the first ndims of the variable and using scatter_update on the subtensors that result of slicing the first dimension. This is a valid option for ndims = 1, but less efficient than this implementation.

count_up_to

View source

count_up_to(
    limit
)

Increments this variable until it reaches limit. (deprecated)

When that Op is run it tries to increment the variable by 1. If incrementing the variable would bring it above limit then the Op raises the exception OutOfRangeError.

If no error is raised, the Op outputs the value of the variable before the increment.

This is essentially a shortcut for count_up_to(self, limit).

eval

View source

eval(
    session=None
)

In a session, computes and returns the value of this variable.

This is not a graph construction method, it does not add ops to the graph.

This convenience method requires a session where the graph containing this variable has been launched. If no session is passed, the default session is used. See tf.compat.v1.Session for more information on launching a graph and on sessions.

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

View source

experimental_ref()

DEPRECATED FUNCTION

from_proto

View source

@staticmethod
from_proto(
    variable_def, import_scope=None
)

Returns a Variable object created from variable_def.

gather_nd

View source

gather_nd(
    indices, name=None
)

Gather slices from params into a Tensor with shape specified by indices.

See tf.gather_nd for details.

get_shape

View source

get_shape()

Alias of Variable.shape.

initialized_value

View source

initialized_value()

Returns the value of the initialized variable. (deprecated)

You should use this instead of the variable itself to initialize another variable with a value that depends on the value of this variable.

# 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

View source

load(
    value, session=None
)

Load new value into this variable. (deprecated)

Writes new value to variable's memory. Doesn't add ops to the graph.

This convenience method requires a session where the graph containing this variable has been launched. If no session is passed, the default session is used. See tf.compat.v1.Session for more information on launching a graph and on sessions.

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

View source

read_value()

Returns the value of this variable, read in the current context.

Can be different from value() if it's on another device, with control dependencies, etc.

ref

View source

ref()

Returns a hashable reference object to this Variable.

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

Следующее приведет к исключению начиная с версии 2.0

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

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

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

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

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

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

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

scatter_add

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

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

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

scatter_div

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

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

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

scatter_max

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

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

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

scatter_min

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

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

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

scatter_mul

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

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

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

scatter_nd_add

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

scatter_nd_add(
    indices, updates, name=None
)

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

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

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

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

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

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

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

v = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
indices = tf.constant([[4], [3], [1] ,[7]])
updates = tf.constant([9, 10, 11, 12])
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
)

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

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

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

Для тензора 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__(
    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
)

__div__

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

__div__(
    x, y
)

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

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

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

__eq__

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

__eq__(
    other
)

Сравнивает два объекта `variable` поэлементно на равенство.

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

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

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

__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) для целых чисел, но использует 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:

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 xor y < 0 равно

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

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

__rmul__

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

__rmul__(
    y, x
)

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

__ror__

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

__ror__(
    y, x
)

__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, где все целочисленные аргументы сначала преобразуются в плавающие типы. Эта операция генерируется обычным делением 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__(
    y, x
)

__sub__

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

__sub__(
    x, y
)

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

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

__truediv__

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

__truediv__(
    x, y
)

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

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

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

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

__xor__

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

__xor__(
    x, y
)