tf.linalg.LinearOperatorInversion

LinearOperator, представляющий обратный оператор другого оператора.

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

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

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

Подробнее см. в руководстве по миграции.

tf.compat.v1.linalg.LinearOperatorInversion

tf.linalg.LinearOperatorInversion(
    operator,
    is_non_singular=None,
    is_self_adjoint=None,
    is_positive_definite=None,
    is_square=None,
    name=None
)

Этот оператор представляет собой обратный оператор другого оператора.

# Create a 2 x 2 linear operator.
operator = LinearOperatorFullMatrix([[1., 0.], [0., 2.]])
operator_inv = LinearOperatorInversion(operator)

operator_inv.to_dense()
==> [[1., 0.]
     [0., 0.5]]

operator_inv.shape
==> [2, 2]

operator_inv.log_abs_determinant()
==> - log(2)

x = ... Shape [2, 4] Tensor
operator_inv.matmul(x)
==> Shape [2, 4] Tensor, equal to operator.solve(x)

Производительность

Производительность LinearOperatorInversion зависит от производительности базовых операторов: solve и matmul меняются местами, а определитель инвертируется.

Подсказки о свойствах матрицы

Этот LinearOperator инициализируется булевыми флагами вида is_X для X = non_singular, self_adjoint, positive_definite, square. Они имеют следующий смысл:

Если is_X == True, вызывающие код должны считать, что оператор обладает свойством X. Это обещание, которое должно выполняться, но не является проверкой во время выполнения. Например, конечная точность чисел с плавающей запятой может привести к нарушению этих обещаний.
Если is_X == False, вызывающие код должны считать, что оператор не обладает X.
Если is_X == None (значение по умолчанию), вызывающий код не должен иметь никаких предположений ни в ту, ни в другую сторону.

Аргументы
`operator`	объект `LinearOperator`. Если `operator.is_non_singular == False`, возникает исключение. Допускается `operator.is_non_singular == None`; в этом случае этот оператор будет иметь `is_non_singular == None`. Аналогично для `is_self_adjoint` и `is_positive_definite`.
`is_non_singular`	Предполагается, что этот оператор невырожденный.
`is_self_adjoint`	Предполагается, что этот оператор равен своему эрмитово-сопряжённому.
`is_positive_definite`	Предполагается, что этот оператор положительно определён, то есть квадратичная форма `x^H A x` имеет положительную действительную часть для всех ненулевых `x`. Обратите внимание: для положительной определённости мы не требуем, чтобы оператор был самосопряжённым. См. https://en.wikipedia.org/wiki/Positive-definite_matrix#Extension_for_non-symmetric_matrices
`is_square`	Предполагается, что этот оператор действует как квадратные [пакетные] матрицы.
`name`	Имя для этого `LinearOperator`. По умолчанию — `operator.name + "_inv"`.

Возникает
`ValueError`	Если `operator.is_non_singular` равно False.

Атрибуты
`H`	Возвращает сопряжённый оператор текущего `LinearOperator`. Для `A`, представляющего этот `LinearOperator`, возвращает `A*`. Обратите внимание, что вызовы `self.adjoint()` и `self.H` эквивалентны.
`batch_shape`	`TensorShape` пакетных измерений этого `LinearOperator`. Если этот оператор действует как пакетная матрица `A` с `A.shape = [B1,...,Bb, M, N]`, то возвращается `TensorShape([B1,...,Bb])`, эквивалентное `A.shape[:-2]`
`domain_dimension`	Размерность (в смысле векторных пространств) области определения этого оператора. Если этот оператор действует как пакетная матрица `A` с `A.shape = [B1,...,Bb, M, N]`, то возвращается `N`.
`dtype`	`DType` `Tensor`, обрабатываемых этим `LinearOperator`.
`graph_parents`	Список зависимостей графа этого `LinearOperator`. (устарело) Устарело: ЭТА ФУНКЦИЯ УСТАРЕЛА. Она будет удалена в одной из будущих версий. Инструкции по обновлению: не вызывайте `graph_parents`.
`is_non_singular`
`is_positive_definite`
`is_self_adjoint`
`is_square`	Возвращает `True/False` в зависимости от того, является ли этот оператор квадратным.
`operator`	Оператор до инвертирования.
`parameters`	Словарь параметров, использованных для создания этого `LinearOperator`.
`range_dimension`	Размерность (в смысле векторных пространств) образа этого оператора. Если этот оператор действует как пакетная матрица `A` с `A.shape = [B1,...,Bb, M, N]`, то возвращается `M`.
`shape`	`TensorShape` этого `LinearOperator`. Если этот оператор действует как пакетная матрица `A` с `A.shape = [B1,...,Bb, M, N]`, то возвращается `TensorShape([B1,...,Bb, M, N])`, эквивалентное `A.shape`.
`tensor_rank`	Ранг (в смысле тензоров) матрицы, соответствующей этому оператору. Если этот оператор действует как пакетная матрица `A` с `A.shape = [B1,...,Bb, M, N]`, то возвращается `b + 2`.

Методы

`add_to_tensor`

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

add_to_tensor(
    x, name='add_to_tensor'
)

Прибавляет матрицу, представленную этим оператором, к x. Эквивалентно A + x.

Аргументы
`x`	`Tensor` с таким же `dtype` и формой, допускающей широковещательную передачу к `self.shape`.
`name`	Имя для этого `Op`.

Возвращает
`Tensor` с формой, полученной широковещательной передачей, и тем же `dtype`, что и у `self`.

`adjoint`

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

adjoint(
    name: str = 'adjoint'
) -> 'LinearOperator'

Возвращает сопряжённый оператор текущего LinearOperator.

Для A, представляющего этот LinearOperator, возвращает A*. Обратите внимание, что вызовы self.adjoint() и self.H эквивалентны.

Аргументы
`name`	Имя для этого `Op`.

Возвращает
`LinearOperator`, представляющий сопряжённый оператор этого `LinearOperator`.

`assert_non_singular`

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

assert_non_singular(
    name='assert_non_singular'
)

Возвращает Op, проверяющий, что этот оператор невырожденный.

Оператор считается невырожденным, если

ConditionNumber < max{100, range_dimension, domain_dimension} * eps,
eps := np.finfo(self.dtype.as_numpy_dtype).eps

Аргументы
`name`	Строковое имя, добавляемое в начало имён созданных операций.

Возвращает
`Assert` `Op`, при выполнении которого будет вызвано `InvalidArgumentError`, если оператор вырожденный.

`assert_positive_definite`

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

assert_positive_definite(
    name='assert_positive_definite'
)

Возвращает Op, проверяющий, что этот оператор положительно определён.

Здесь положительная определённость означает, что квадратичная форма x^H A x имеет положительную действительную часть для всех ненулевых x. Обратите внимание: для положительной определённости мы не требуем, чтобы оператор был самосопряжённым.

Аргументы
`name`	Имя для этого `Op`.

Возвращает
`Assert` `Op`, при выполнении которого будет вызвано `InvalidArgumentError`, если оператор не является положительно определённым.

`assert_self_adjoint`

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

assert_self_adjoint(
    name='assert_self_adjoint'
)

Возвращает Op, проверяющий, что этот оператор самосопряжённый.

Здесь проверяется, что этот оператор в точности равен своему эрмитово-сопряжённому.

Аргументы
`name`	Строковое имя, добавляемое в начало имён созданных операций.

Возвращает
`Assert` `Op`, при выполнении которого будет вызвано `InvalidArgumentError`, если оператор не является самосопряжённым.

`batch_shape_tensor`

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

batch_shape_tensor(
    name='batch_shape_tensor'
)

Форма пакетных измерений этого оператора, определяемая во время выполнения.

Если этот оператор действует как пакетная матрица A с A.shape = [B1,...,Bb, M, N], то возвращается Tensor, содержащий [B1,...,Bb].

Аргументы
`name`	Имя для этого `Op`.

Возвращает
`int32` `Tensor`

`cholesky`

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

cholesky(
    name: str = 'cholesky'
) -> 'LinearOperator'

Возвращает множитель Холецкого в виде LinearOperator.

Для A, представляющего этот LinearOperator, если A является положительно определённым самосопряжённым оператором, возвращает L, где A = L L^T, то есть разложение Холецкого.

Аргументы
`name`	Имя для этого `Op`.

Возвращает
`LinearOperator`, представляющий нижнюю треугольную матрицу в разложении Холецкого.

Возникает
`ValueError`	Если для `LinearOperator` не указана подсказка о положительной определённости и самосопряжённости.

`cond`

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

cond(
    name='cond'
)

Возвращает число обусловленности этого линейного оператора.

Аргументы
`name`	Имя для этого `Op`.

Возвращает
Форма `[B1,...,Bb]` `Tensor` с тем же `dtype`, что и у `self`.

`determinant`

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

determinant(
    name='det'
)

Определитель для каждого элемента пакета.

Аргументы
`name`	Имя для этого `Op`.

Возвращает
`Tensor` с формой `self.batch_shape` и тем же `dtype`, что и у `self`.

Возникает
`NotImplementedError`	Если `self.is_square` — это `False`.

`diag_part`

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

diag_part(
    name='diag_part'
)

Эффективно получает диагональную часть [пакетной] матрицы этого оператора.

Если форма этого оператора — [B1,...,Bb, M, N], возвращается Tensor diagonal формы [B1,...,Bb, min(M, N)], где diagonal[b1,...,bb, i] = self.to_dense()[b1,...,bb, i, i].

my_operator = LinearOperatorDiag([1., 2.])

# Efficiently get the diagonal
my_operator.diag_part()
==> [1., 2.]

# Equivalent, but inefficient method
tf.linalg.diag_part(my_operator.to_dense())
==> [1., 2.]

Аргументы
`name`	Имя для этого `Op`.

Возвращает
`diag_part`	`Tensor` с тем же `dtype`, что и у объекта self.

`domain_dimension_tensor`

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

domain_dimension_tensor(
    name='domain_dimension_tensor'
)

Размерность (в смысле векторных пространств) области определения этого оператора.

Определяется во время выполнения.

Если этот оператор действует как пакетная матрица A с A.shape = [B1,...,Bb, M, N], то возвращается N.

Аргументы
`name`	Имя для этого `Op`.

Возвращает
`int32` `Tensor`

`eigvals`

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

eigvals(
    name='eigvals'
)

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

Если оператор помечен как самосопряжённый (с помощью is_self_adjoint), вычисление может выполняться эффективнее.

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

Аргументы
`name`	Имя для этого `Op`.

Возвращает
Форма `[B1,...,Bb, N]` `Tensor` с тем же `dtype`, что и у `self`.

`inverse`

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

inverse(
    name: str = 'inverse'
) -> 'LinearOperator'

Возвращает обратный оператор этого LinearOperator.

Для A, представляющего этот LinearOperator, возвращает LinearOperator, представляющий A^-1.

Аргументы
`name`	Область имён, используемая для операций, добавляемых этим методом.

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

Возникает
`ValueError`	Если для `LinearOperator` не указана подсказка, что он является `non_singular`.

`log_abs_determinant`

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

log_abs_determinant(
    name='log_abs_det'
)

Логарифм абсолютного значения определителя для каждого элемента пакета.

Аргументы
`name`	Имя для этого `Op`.

Возвращает
`Tensor` с формой `self.batch_shape` и тем же `dtype`, что и у `self`.

Возникает
`NotImplementedError`	Если `self.is_square` — это `False`.

`matmul`

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

matmul(
    x, adjoint=False, adjoint_arg=False, name='matmul'
)

Преобразует [пакетную] матрицу x умножением слева: x --> Ax.

# Make an operator acting like batch matrix A.  Assume A.shape = [..., M, N]
operator = LinearOperator(...)
operator.shape = [..., M, N]

X = ... # shape [..., N, R], batch matrix, R > 0.

Y = operator.matmul(X)
Y.shape
==> [..., M, R]

Y[..., :, r] = sum_j A[..., :, j] X[j, r]

Аргументы
`x`	`LinearOperator` или `Tensor` с совместимой формой и тем же `dtype`, что и у `self`. Определение совместимости см. в строке документации класса.
`adjoint`	`bool` Python. Если `True`, умножает слева на сопряжённый оператор: `A^H x`.
`adjoint_arg`	`bool` Python. Если `True`, вычисляет `A x^H`, где `x^H` — эрмитово-сопряжённая матрица (транспонирование и комплексное сопряжение).
`name`	Имя для этого `Op`.

Возвращает
`LinearOperator` или `Tensor` с формой `[..., M, R]` и тем же `dtype`, что и у `self`.

`matvec`

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

matvec(
    x, adjoint=False, name='matvec'
)

Преобразует [пакетный] вектор x умножением слева: x --> Ax.

# Make an operator acting like batch matrix A.  Assume A.shape = [..., M, N]
operator = LinearOperator(...)

X = ... # shape [..., N], batch vector

Y = operator.matvec(X)
Y.shape
==> [..., M]

Y[..., :] = sum_j A[..., :, j] X[..., j]

Аргументы
`x`	`Tensor` с совместимой формой и тем же `dtype`, что и у `self`. `x` рассматривается как [пакетный] вектор: для каждого набора ведущих измерений последнее измерение задаёт вектор. Определение совместимости см. в строке документации класса.
`adjoint`	`bool` Python. Если `True`, умножает слева на сопряжённый оператор: `A^H x`.
`name`	Имя для этого `Op`.

Возвращает
`Tensor` с формой `[..., M]` и тем же `dtype`, что и у `self`.

`range_dimension_tensor`

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

range_dimension_tensor(
    name='range_dimension_tensor'
)

Размерность (в смысле векторных пространств) образа этого оператора.

Определяется во время выполнения.

Если этот оператор действует как пакетная матрица A с A.shape = [B1,...,Bb, M, N], то возвращается M.

Аргументы
`name`	Имя для этого `Op`.

Возвращает
`int32` `Tensor`

`shape_tensor`

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

shape_tensor(
    name='shape_tensor'
)

Форма этого LinearOperator, определяемая во время выполнения.

Если этот оператор действует как пакетная матрица A с A.shape = [B1,...,Bb, M, N], то возвращается Tensor, содержащий [B1,...,Bb, M, N], эквивалентное tf.shape(A).

Аргументы
`name`	Имя для этого `Op`.

Возвращает
`int32` `Tensor`

`solve`

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

solve(
    rhs, adjoint=False, adjoint_arg=False, name='solve'
)

Решает (точно или приближённо) R пакетных систем уравнений: A X = rhs.

Возвращённое значение Tensor будет близко к точному решению, если A хорошо обусловлена. В противном случае степень близости будет различаться. Подробности см. в строке документации класса.

Примеры:

# Make an operator acting like batch matrix A.  Assume A.shape = [..., M, N]
operator = LinearOperator(...)
operator.shape = [..., M, N]

# Solve R > 0 linear systems for every member of the batch.
RHS = ... # shape [..., M, R]

X = operator.solve(RHS)
# X[..., :, r] is the solution to the r'th linear system
# sum_j A[..., :, j] X[..., j, r] = RHS[..., :, r]

operator.matmul(X)
==> RHS

Аргументы
`rhs`	`Tensor` с тем же `dtype`, что и у этого оператора, и совместимой формой. `rhs` рассматривается как [пакетная] матрица: для каждого набора ведущих измерений последние два измерения определяют матрицу. Определение совместимости см. в документации класса.
`adjoint`	`bool` Python. Если `True`, решить систему с использованием сопряжённого оператора `LinearOperator`: `A^H X = rhs`.
`adjoint_arg`	`bool` Python. Если `True`, решить `A X = rhs^H`, где `rhs^H` — эрмитово сопряжение (транспонирование и комплексное сопряжение).
`name`	Область имён для операций, добавляемых этим методом.

Возвращает
`Tensor` с формой `[...,N, R]` и тем же `dtype`, что и у `rhs`.

Вызывает исключения
`NotImplementedError`	Если `self.is_non_singular` или `is_square` имеет значение False.

`solvevec`

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

solvevec(
    rhs, adjoint=False, name='solve'
)

Решает уравнение с наилучшим доступным результатом: A X = rhs.

Возвращаемое значение Tensor будет близко к точному решению, если A хорошо обусловлена. В противном случае степень близости будет различаться. Подробнее см. в документации класса.

Примеры:

# Make an operator acting like batch matrix A.  Assume A.shape = [..., M, N]
operator = LinearOperator(...)
operator.shape = [..., M, N]

# Solve one linear system for every member of the batch.
RHS = ... # shape [..., M]

X = operator.solvevec(RHS)
# X is the solution to the linear system
# sum_j A[..., :, j] X[..., j] = RHS[..., :]

operator.matvec(X)
==> RHS

Аргументы
`rhs`	`Tensor` с тем же `dtype`, что и у этого оператора. `rhs` рассматривается как [пакетный] вектор: для каждого набора ведущих измерений последнее измерение определяет вектор. Определение совместимости пакетных измерений см. в документации класса.
`adjoint`	`bool` Python. Если `True`, решить систему с использованием сопряжённого оператора `LinearOperator`: `A^H X = rhs`.
`name`	Область имён для операций, добавляемых этим методом.

Возвращает
`Tensor` с формой `[...,N]` и тем же `dtype`, что и у `rhs`.

Вызывает исключения
`NotImplementedError`	Если `self.is_non_singular` или `is_square` имеет значение False.

`tensor_rank_tensor`

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

tensor_rank_tensor(
    name='tensor_rank_tensor'
)

Ранг (в смысле тензоров) матрицы, соответствующей этому оператору.

Если этот оператор действует как пакетная матрица A с A.shape = [B1,...,Bb, M, N], этот метод возвращает b + 2.

Аргументы
`name`	Имя для этого `Op`.

Возвращает
`int32` `Tensor`, определяемое во время выполнения.

`to_dense`

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

to_dense(
    name='to_dense'
)

Возвращает плотную (пакетную) матрицу, представляющую этот оператор.

`trace`

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

trace(
    name='trace'
)

След линейного оператора, равный сумме self.diag_part().

Если оператор квадратный, это также сумма собственных значений.

Аргументы
`name`	Имя для этого `Op`.

Возвращает
Форма `[B1,...,Bb]` `Tensor` с тем же `dtype`, что и у `self`.

`getitem`

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

__getitem__(
    slices
)

`matmul`

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

__matmul__(
    other
)

© 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/LinearOperatorInversion