tf.Tensor

Представляет один из выходов Operation.

tf.Tensor(
    op, value_index, dtype
)

Тензор — это символическая ссылка на один из выходов Operation. Он не содержит значения результата этой операции, а вместо этого предоставляет способ вычисления этих значений в TensorFlow tf.compat.v1.Session.

Этот класс имеет две основные цели:

1. Тензор можно передать в качестве входного значения для другой Operation. Это создает соединение потока данных между операциями, что позволяет TensorFlow выполнить всю Graph , представляющую собой вычисление из нескольких этапов.

2. После запуска графа в сессии значение тензора можно вычислить, передав его в tf.Session.run. t.eval() — это сокращение вызова tf.compat.v1.get_default_session().run(t).

В следующем примере c, d, и e — это символические объекты Tensor, а result — массив NumPy, который хранит конкретное значение:

# Build a dataflow graph.
c = tf.constant([[1.0, 2.0], [3.0, 4.0]])
d = tf.constant([[1.0, 1.0], [0.0, 1.0]])
e = tf.matmul(c, d)

# Construct a `Session` to execute the graph.
sess = tf.compat.v1.Session()

# Execute the graph and store the value that `e` represents in `result`.
result = sess.run(e)

c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])

print(c.shape)
==> TensorShape([Dimension(2), Dimension(3)])

d = tf.constant([[1.0, 0.0], [0.0, 1.0], [1.0, 0.0], [0.0, 1.0]])

print(d.shape)
==> TensorShape([Dimension(4), Dimension(2)])

# Raises a ValueError, because `c` and `d` do not have compatible
# inner dimensions.
e = tf.matmul(c, d)

f = tf.matmul(c, d, transpose_a=True, transpose_b=True)

print(f.shape)
==> TensorShape([Dimension(3), Dimension(4)])

Методы

consumers

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

consumers()

Возвращает список Operations, которые потребляют этот тензор.

eval

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

eval(
    feed_dict=None, session=None
)

Вычисляет этот тензор в Session.

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

Примечание: Перед вызовом Tensor.eval() его граф должен быть запущен в сессии, и либо должна быть доступна сессия по умолчанию, либо session должна быть указана явно.

experimental_ref

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

experimental_ref()

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

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

import tensorflow as tf

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

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

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

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

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

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

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

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

x = tf.constant(5)
print(x.experimental_ref().deref())
==> tf.Tensor(5, shape=(), dtype=int32)

get_shape

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

get_shape()

Псевдоним для Tensor.shape.

set_shape

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

set_shape(
    shape
)

Обновляет форму этого тензора.

Этот метод можно вызывать несколько раз, и он будет объединять заданную shape с текущей формой этого тензора. Его можно использовать для предоставления дополнительной информации о форме этого тензора, которую нельзя вывести только из графа. Например, это можно использовать для предоставления дополнительной информации о формах изображений:

_, image_data = tf.compat.v1.TFRecordReader(...).read(...)
image = tf.image.decode_png(image_data, channels=3)

# The height and width dimensions of `image` are data dependent, and
# cannot be computed without executing the op.
print(image.shape)
==> TensorShape([Dimension(None), Dimension(None), Dimension(3)])

# We know that each image in this dataset is 28 x 28 pixels.
image.set_shape([28, 28, 3])
print(image.shape)
==> TensorShape([Dimension(28), Dimension(28), Dimension(3)])

Примечание: Эта форма не проверяется во время выполнения. Установка некорректных форм может привести к несоответствиям между статически известным графом и значением тензоров во время выполнения. Для проверки формы во время выполнения используйте tf.ensure_shape вместо этого.

__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_v2 для всех других типов.

__and__

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

__and__(
    x, y
)

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

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

__bool__

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

__bool__()

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

Этот перегруз вызывает TypeError, когда пользователь непреднамеренно использует Tensor как булево значение (чаще всего в операторе if или while), в коде, который не был преобразован AutoGraph. Например:

if tf.constant(True):  # Will raise.
  # ...

if tf.constant(5) < tf.constant(7):  # Will raise.
  # ...

__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)) для аргументов с плавающей запятой, чтобы результат всегда был целым числом (возможно, целым числом, представленным как число с плавающей запятой). Этот оператор генерируется операцией целочисленного деления с округлением вниз в Python 3 и в Python 2.7 с from __future__ import division.

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

__ge__

__ge__(
    x, y, name=None
)

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

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

__getitem__

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

__getitem__(
    tensor, slice_spec, var=None
)

Перегрузка для Tensor.getitem.

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

Некоторые полезные примеры:

# Strip leading and trailing 2 elements
foo = tf.constant([1,2,3,4,5,6])
print(foo[2:-2].eval())  # => [3,4]

# Skip every other row and reverse the order of the columns
foo = tf.constant([[1,2,3], [4,5,6], [7,8,9]])
print(foo[::2,::-1].eval())  # => [[3,2,1], [9,8,7]]

# Use scalar tensors as indices on both dimensions
print(foo[tf.constant(0), tf.constant(2)].eval())  # => 3

# Insert another dimension
foo = tf.constant([[1,2,3], [4,5,6], [7,8,9]])
print(foo[tf.newaxis, :, :].eval()) # => [[[1,2,3], [4,5,6], [7,8,9]]]
print(foo[:, tf.newaxis, :].eval()) # => [[[1,2,3]], [[4,5,6]], [[7,8,9]]]
print(foo[:, :, tf.newaxis].eval()) # => [[[1],[2],[3]], [[4],[5],[6]],
[[7],[8],[9]]]

# Ellipses (3 equivalent operations)
foo = tf.constant([[1,2,3], [4,5,6], [7,8,9]])
print(foo[tf.newaxis, :, :].eval())  # => [[[1,2,3], [4,5,6], [7,8,9]]]
print(foo[tf.newaxis, ...].eval())  # => [[[1,2,3], [4,5,6], [7,8,9]]]
print(foo[tf.newaxis].eval())  # => [[[1,2,3], [4,5,6], [7,8,9]]]

# Masks
foo = tf.constant([[1,2,3], [4,5,6], [7,8,9]])
print(foo[foo > 2].eval())  # => [3, 4, 5, 6, 7, 8, 9]

Примечания:

• tf.newaxis эквивалентен None в NumPy.
• Неявный эллипс помещается в конце slice_spec
• Расширенная индексация NumPy в настоящее время не поддерживается.

__gt__

__gt__(
    x, y, name=None
)

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

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

__invert__

__invert__(
    x, name=None
)

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

__iter__

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

__iter__()

__le__

__le__(
    x, y, name=None
)

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

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

__len__

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

__len__()

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

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

__ne__

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

__ne__(
    other
)

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

__neg__

__neg__(
    x, name=None
)

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

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

__nonzero__

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

__nonzero__()

Метод-заглушка, чтобы предотвратить использование тензора как Python bool.

Это аналог функции __bool__() из Python 2.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)) для чисел с плавающей точкой, чтобы результат всегда был целым числом (хотя, возможно, представленным как число с плавающей точкой). Данная операция генерируется операцией целочисленного деления с округлением вниз в 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 или y < 0 истинно, это соответствует семантике Python, в том смысле, что результат здесь согласуется с округлением в меньшую сторону. Например, floor(x / y) * y + mod(x, y) = x.

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

__rmul__

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

__rmul__(
    y, x
)

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

__ror__

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

__ror__(
    y, x
)

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

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

__rpow__

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

__rpow__(
    y, x
)

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

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

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

__rsub__

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

__rsub__(
    y, x
)

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

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

__rtruediv__

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

__rtruediv__(
    y, x
)

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

Переменные класса

• OVERLOADABLE_OPERATORS