tf.experimental.dtensor.DVariable

Замена для tf.Variable, которая следует принципу размещения начального значения.

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

tf.experimental.dtensor.DVariable(
    initial_value, *args, dtype=None, **kwargs
)

Класс также обрабатывает операции restore/save в DTensor. Обратите внимание, что DVariable может перейти к обычному tf.Variable в данный момент, если initial_value не является DTensor.

Подклассы

class SaveSliceInfo

Методы

assign

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

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

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

assign_add

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

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

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

assign_sub

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

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

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

batch_scatter_update

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

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

Присваивает tf.IndexedSlices этой переменной по частям.

Аналогично batch_gather. Предполагается, что у этой переменной и IndexedSlices sparse_delta есть ряд ведущих измерений, которые одинаковы для всех них, и обновления выполняются в последнем измерении индексов. Другими словами, измерения должны быть следующими:

num_prefix_dims = sparse_delta.indices.ndims - 1 batch_dim = num_prefix_dims + 1 sparse_delta.updates.shape = sparse_delta.indices.shape + var.shape[ batch_dim:]

где

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

И выполняемая операция может быть выражена как:

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

Когда sparse_delta.indices является одномерным тензором, эта операция эквивалентна scatter_update.

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

count_up_to

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

count_up_to(
    limit
)

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

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

Если исключение не возникает, операция возвращает значение переменной до увеличения.

В сущности, это сокращение для count_up_to(self, limit).

eval

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

eval(
    session=None
)

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

experimental_ref

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

experimental_ref()

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

from_proto

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

@staticmethod
from_proto(
    variable_def, import_scope=None
)

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

gather_nd

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

gather_nd(
    indices, name=None
)

Читает значение этой переменной фрагментарно, используя 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)

is_initialized

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

is_initialized(
    name=None
)

Проверяет, была ли инициализирована переменная ресурса.

Выводит скалярный булевый тип, указывающий, была ли инициализирована тензор.

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]

numpy

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

numpy()

read_value

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

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

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

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

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

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

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

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

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

ref = 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 = ref.scatter_nd_add(indices, updates)
with tf.compat.v1.Session() as sess:
  print sess.run(add)

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

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

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

scatter_nd_max

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

scatter_nd_max(
    indices, updates, name=None
)

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

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

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

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

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

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

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

scatter_nd_min

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

scatter_nd_min(
    indices, updates, name=None
)

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

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

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

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

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

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

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

scatter_nd_sub

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

scatter_nd_sub(
    indices, updates, name=None
)

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

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

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

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

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

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

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

ref = 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 = ref.scatter_nd_sub(indices, updates)
with tf.compat.v1.Session() as sess:
  print sess.run(op)

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

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

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

scatter_nd_update

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

scatter_nd_update(
    indices, updates, name=None
)

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

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

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

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

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

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

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

ref = 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 = ref.scatter_nd_update(indices, updates)
with tf.compat.v1.Session() as sess:
  print sess.run(op)

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

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

Считывает значение этой переменной разреженно, используя gather.

to_proto

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

to_proto(
    export_scope=None
)

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

value

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

value()

Кэшированная операция, которая считывает значение этой переменной.

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

__array__

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

__array__(
    dtype=None
)

Позволяет прямое преобразование в массив numpy.

np.array(tf.Variable([1.0]))
array([1.], dtype=float32)

__bool__

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

__bool__()

__div__

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

__div__(
    y
)

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

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

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

__eq__

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

__eq__(
    other
)

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

__floordiv__

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

__floordiv__(
    y
)

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

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

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

__ge__

__ge__(
    y, name=None
)

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

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

Пример:

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

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

__getitem__

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

__getitem__(
    slice_spec
)

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

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

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

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

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

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

__gt__

__gt__(
    y, name=None
)

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

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

Пример:

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

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

__invert__

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

__invert__(
    name=None
)

__iter__

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

__iter__()

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

__le__

__le__(
    y, name=None
)

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

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

Пример:

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

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

__lt__

__lt__(
    y, name=None
)

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

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

Пример:

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

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

__matmul__

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

__matmul__(
    y
)

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

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

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

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

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

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

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

Умножение матриц в пакете с формой пакета [2]:

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

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

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

__mod__

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

__mod__(
    y
)

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

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

__mul__

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

__mul__(
    y
)

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

__ne__

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

__ne__(
    other
)

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

__neg__

__neg__(
    name=None
)

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

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

__nonzero__

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

__nonzero__()

__or__

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

__or__(
    y
)

__pow__

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

__pow__(
    y
)

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

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

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

__radd__

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

__radd__(
    x
)

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

Цель в API:

Этот метод экспонируется в API TensorFlow, чтобы разработчики библиотек могли регистрировать диспетчеризацию для Tensor.add, чтобы разрешить обработку пользовательских составных тензоров и других пользовательских объектов.

Символ API не предназначен для прямого вызова пользователями и появляется в сгенерированной документации TensorFlow.

__rand__

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

__rand__(
    x
)

__rdiv__

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

__rdiv__(
    x
)

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

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

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

__rfloordiv__

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

__rfloordiv__(
    x
)

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

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

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

__rmatmul__

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

__rmatmul__(
    x
)

Умножает матрицу a на матрицу b, производя a * b.

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

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

Матрицу можно транспонировать или сопрячь (сопряжённо-транспонировать) на лету, установив соответствующий флаг в True. По умолчанию эти флаги 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)>

Умножение матриц с набором (batch) размером [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
)

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

__ror__

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

__ror__(
    x
)

__rpow__

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

__rpow__(
    x
)

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

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

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

__rsub__

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

__rsub__(
    x
)

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

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

Диапазон входных и выходных данных (-inf, inf).

Примеры использования ниже.

Операция вычитания между массивом и скаляром:

x = [1, 2, 3, 4, 5]
y = 1
tf.subtract(x, y)
<tf.Tensor: shape=(5,), dtype=int32, numpy=array([0, 1, 2, 3, 4], dtype=int32)>
tf.subtract(y, x)
<tf.Tensor: shape=(5,), dtype=int32,
numpy=array([ 0, -1, -2, -3, -4], dtype=int32)>

Обратите внимание, что вместо этого можно использовать бинарный оператор -:

x = tf.convert_to_tensor([1, 2, 3, 4, 5])
y = tf.convert_to_tensor(1)
x - y
<tf.Tensor: shape=(5,), dtype=int32, numpy=array([0, 1, 2, 3, 4], dtype=int32)>

Операция вычитания между массивом и тензором той же формы:

x = [1, 2, 3, 4, 5]
y = tf.constant([5, 4, 3, 2, 1])
tf.subtract(y, x)
<tf.Tensor: shape=(5,), dtype=int32,
numpy=array([ 4,  2,  0, -2, -4], dtype=int32)>

Например,

x = tf.constant([1, 2], dtype=tf.int8)
y = [2**8 + 1, 2**8 + 2]
tf.subtract(x, y)
<tf.Tensor: shape=(2,), dtype=int8, numpy=array([0, 0], dtype=int8)>

При вычитании двух входных значений с разными формами, tf.subtract следует общим правилам векторизации здесь. Формы двух входных массивов сравниваются поэлементно. Начиная с последних измерений, два измерения должны быть равны или одно из них должно быть 1.

Например,

x = np.ones(6).reshape(2, 3, 1)
y = np.ones(6).reshape(2, 1, 3)
tf.subtract(x, y)
<tf.Tensor: shape=(2, 3, 3), dtype=float64, numpy=
array([[[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]],
       [[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]]])>

Пример с входными данными разных размерностей:

x = np.ones(6).reshape(2, 3, 1)
y = np.ones(6).reshape(1, 6)
tf.subtract(x, y)
<tf.Tensor: shape=(2, 3, 6), dtype=float64, numpy=
array([[[0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.]],
       [[0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.]]])>

__rtruediv__

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

__rtruediv__(
    x
)

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

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

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

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

__rxor__

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

__rxor__(
    x
)

__sub__

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

__sub__(
    y
)

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

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

И вход, и выход имеют диапазон (-inf, inf).

Примеры использования ниже.

Операция вычитания между массивом и скаляром:

x = [1, 2, 3, 4, 5]
y = 1
tf.subtract(x, y)
<tf.Tensor: shape=(5,), dtype=int32, numpy=array([0, 1, 2, 3, 4], dtype=int32)>
tf.subtract(y, x)
<tf.Tensor: shape=(5,), dtype=int32,
numpy=array([ 0, -1, -2, -3, -4], dtype=int32)>

Обратите внимание, что вместо этого можно использовать бинарный - оператор:

x = tf.convert_to_tensor([1, 2, 3, 4, 5])
y = tf.convert_to_tensor(1)
x - y
<tf.Tensor: shape=(5,), dtype=int32, numpy=array([0, 1, 2, 3, 4], dtype=int32)>

Операция вычитания между массивом и тензором той же формы:

x = [1, 2, 3, 4, 5]
y = tf.constant([5, 4, 3, 2, 1])
tf.subtract(y, x)
<tf.Tensor: shape=(5,), dtype=int32,
numpy=array([ 4,  2,  0, -2, -4], dtype=int32)>

Например,

x = tf.constant([1, 2], dtype=tf.int8)
y = [2**8 + 1, 2**8 + 2]
tf.subtract(x, y)
<tf.Tensor: shape=(2,), dtype=int8, numpy=array([0, 0], dtype=int8)>

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

Например,

x = np.ones(6).reshape(2, 3, 1)
y = np.ones(6).reshape(2, 1, 3)
tf.subtract(x, y)
<tf.Tensor: shape=(2, 3, 3), dtype=float64, numpy=
array([[[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]],
       [[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]]])>

Пример с входными данными разных размерностей:

x = np.ones(6).reshape(2, 3, 1)
y = np.ones(6).reshape(1, 6)
tf.subtract(x, y)
<tf.Tensor: shape=(2, 3, 6), dtype=float64, numpy=
array([[[0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.]],
       [[0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0.]]])>

__truediv__

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

__truediv__(
    y
)

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

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