tf.linalg.matmul

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

Просмотр псевдонимов

Основные псевдонимы

tf.matmul

Псевдонимы совместимости для миграции

См. Руководство по миграции для получения дополнительной информации.

tf.compat.v1.matmul

tf.linalg.matmul(
    a,
    b,
    transpose_a=False,
    transpose_b=False,
    adjoint_a=False,
    adjoint_b=False,
    a_is_sparse=False,
    b_is_sparse=False,
    output_type=None,
    grad_a=False,
    grad_b=False,
    name=None
)

Используется в блокнотах

Используется в руководстве	Используется в учебниках
Использование GPU Введение в модули, слои и модели Концепции DTensors Введение в графы и tf.function Использование моделей TF1.x в рабочих процессах TF2	Основы настройки: тензоры и операции Настраиваемые слои Распределенное обучение с DTensors Байесовская гауссова смесь и гамильтонов MCMC Оптимизаторы в TensorFlow Probability

Входные данные должны, после любых транспонирований, быть тензорами ранга >= 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]])

Аргументы
`a`	`tf.Tensor` типа `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128` и ранга > 1.
`b`	`tf.Tensor` с тем же типом и рангом, что и `a`.
`transpose_a`	Если `True`, `a` транспонируется перед умножением.
`transpose_b`	Если `True`, `b` транспонируется перед умножением.
`adjoint_a`	Если `True`, `a` сопрягается и транспонируется перед умножением.
`adjoint_b`	Если `True`, `b` сопрягается и транспонируется перед умножением.
`a_is_sparse`	Если `True`, `a` обрабатывается как разреженная матрица. Обратите внимание, что это не поддерживает `tf.sparse.SparseTensor`, это просто оптимизации, предполагающие, что большинство значений в `a` равны нулю. См. `tf.sparse.sparse_dense_matmul` для некоторой поддержки умножения `tf.sparse.SparseTensor`.
`b_is_sparse`	Если `True`, `b` обрабатывается как разреженная матрица. Обратите внимание, что это не поддерживает `tf.sparse.SparseTensor`, это просто оптимизации, предполагающие, что большинство значений в `b` равны нулю. См. `tf.sparse.sparse_dense_matmul` для некоторой поддержки умножения `tf.sparse.SparseTensor`.
`output_type`	Тип данных выходных данных при необходимости. По умолчанию None, в этом случае тип выходных данных совпадает с типом входных данных. В настоящее время работает только тогда, когда входные тензоры имеют тип (u)int8, а выходной тип может быть int32.
`grad_a`	Установите его в значение `True`, чтобы указать, что тензор `a` предназначен для обратного прохода.
`grad_b`	Установите его в значение `True`, чтобы указать, что тензор `b` предназначен для обратного прохода.
`name`	Название операции (необязательно).

Возвращаемые значения

Возвращаемые значения
A `tf.Tensor` того же типа, что и `a` и `b`, где каждая внутренняя матрица является произведением соответствующих матриц в `a` и `b`, например, если все атрибуты транспонирования или сопряжения равны `False`: `output[..., i, j] = sum_k (a[..., i, k] * b[..., k, j])` для всех индексов `i`, `j`.
`Note`	Это матричное произведение, а не поэлементное произведение.

A tf.Tensor того же типа, что и a и b, где каждая внутренняя матрица является произведением соответствующих матриц в a и b, например, если все атрибуты транспонирования или сопряжения равны False:

output[..., i, j] = sum_k (a[..., i, k] * b[..., k, j]) для всех индексов i, j.

Note Это матричное произведение, а не поэлементное произведение.

Исключения
`ValueError`	Если `transpose_a` и `adjoint_a`, или `transpose_b` и `adjoint_b` оба установлены в значение `True`.
`TypeError`	Если output_type указан, но типы `a`, `b` и `output_type` не (u)int8, (u)int8 и int32.

© 2022 The TensorFlow Authors. All rights reserved.
Licensed under the Creative Commons Attribution License 4.0.
Code samples licensed under the Apache 2.0 License.
https://www.tensorflow.org/api_docs/python/tf/linalg/matmul