Нахождение наименьших собственных векторов большой разреженной матрицы, в SciPy более чем в 100 раз медленнее, чем в Octave

Я пытаюсь вычислить несколько (5-500) собственных векторов, соответствующих наименьшим собственным значениям больших симметричных квадратных разреженных матриц (до 30000x30000) с ненулевыми значениями менее 0,1%.

В настоящее время я использую scipy.sparse.linalg.eigsh в режиме shift-invert (sigma = 0.0), который, как я выяснил, в различных сообщениях на эту тему является предпочтительным решением. Однако для решения проблемы в большинстве случаев требуется до 1 часа. С другой стороны, функция очень быстрая, если я запрашиваю самые большие собственные значения (в секундах в моей системе), что ожидалось из документации.

Поскольку я больше знаком с Matlab с работы, я попытался решить проблему в Octave, которая дала мне тот же результат, используя eigs (sigma = 0) всего за несколько секунд (sub 10s). Поскольку я хочу выполнить поиск параметров алгоритма, включая вычисление собственных векторов, такой выигрыш во времени был бы также полезен в python.

Сначала я изменил параметры (особенно допуск), но это не сильно изменилось в сроки.

Я использую Anaconda в Windows, но попытался переключить LAPACK / BLAS, используемый scipy (что было очень трудно), с mkl (по умолчанию Anaconda) на OpenBlas (используемый Octave в соответствии с документацией), но не увидел изменений в представление.

Я не смог выяснить, было ли что-то изменить в используемом ARPACK (и как)?

Я загрузил тестовый пример для кода ниже в следующую папку dropbox: https://www.dropbox.com/sh/l6aa6izufzyzqr3/AABqij95hZOvRpnnjRaETQmka?dl=0

В питоне

import numpy as np
from scipy.sparse import csr_matrix, csc_matrix, linalg, load_npz   
M = load_npz('M.npz')
evals, evecs = linalg.eigsh(M,k=6,sigma=0.0)

В октаве:

M=dlmread('M.txt');
M=spconvert(M);
[evecs,evals] = eigs(M,6,0);

Любая помощь ценится!

Некоторые дополнительные опции, которые я опробовал на основе комментариев и предложений:

Октава: eigs(M,6,0)и eigs(M,6,'sm')дай мне тот же результат:

[1.8725e-05 1.0189e-05 7.5622e-06 7.5420e-07 -1.2239e-18 -2.5674e-16]

пока eigs(M,6,'sa',struct('tol',2))сходится к

[1.0423 2.7604 6.1548 11.1310 18.0207 25.3933] 

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

Python: eigsh(M,k=6,which='SA')и eigsh(M,k=6,which='SM')оба не сходятся (ошибка ARPACK при отсутствии достигнутой конвергенции). Только eigsh(M,k=6,sigma=0.0)дает некоторые собственные значения (после почти часа), которые отличаются от октавы для самых маленьких (найдено даже 1 дополнительное небольшое значение):

[3.82923317e-17 3.32269886e-16 2.78039665e-10 7.54202273e-07 7.56251500e-06 1.01893934e-05]

Если допуск достаточно высок, я также получаю результаты eigsh(M,k=6,which='SA',tol='1'), которые приближаются к другим полученным значениям

[4.28732218e-14 7.54194948e-07 7.56220703e-06 1.01889544e-05, 1.87247350e-05 2.02652719e-05]

снова с другим количеством маленьких собственных значений. Время вычислений все еще почти 30 минут. В то время как различные очень маленькие значения могут быть понятны, так как они могут представлять кратные 0, различная множественность сбивает с толку меня.

Кроме того, в SciPy и Octave, похоже, есть некоторые принципиальные различия, которые я пока не могу понять.

Гипотеза и некоторые комментарии, так как у меня нет Matlab / Octave:

Чтобы найти малые собственные значения симметричных матриц с собственными значениями> = 0, как и у вас, следующее быстрее, чем инверсия сдвига:

# flip eigenvalues e.g.
# A:     0 0 0 ... 200 463
# Aflip: 0 163 ... 463 463 463
maxeval = eigsh( A, k=1 )[0]  # biggest, fast
Aflip = maxeval * sparse.eye(n) - A
bigevals, evecs = eigsh( Aflip, which="LM", sigma=None ... )  # biggest, near 463
evals = maxeval - bigevals  # flip back, near 463 -> near 0
# evecs are the same

eigsh( Aflip )для больших собственных пар быстрее, чем инвертирование сдвига, для маленьких, потому что A * xэто быстрее, чем solve()должно делать инвертирование сдвига. Matlab / Octave, возможно, могли бы сделать это Aflipавтоматически, после быстрой проверки на положительную определенность с помощью Cholesky.
Можете ли вы бегать eigsh( Aflip )в Matlab / Octave?

Другие факторы, которые могут повлиять на точность / скорость:

Arpack по умолчанию для начального вектора v0является случайным вектором. Я использую v0 = np.ones(n), что может быть ужасно для некоторых, Aно воспроизводимо :)

Эта Aматрица почти точно сигулярная, A * ones~ 0.

Multicore: scipy-arpack с openblas / Lapack использует ~ 3,9 из 4 ядер на моем iMac; Matlab / Octave используют все ядра?

k 10  tol 1e-05:    8 sec  eigvals [0 8.5e-05 0.00043 0.0014 0.0026 0.0047 0.0071 0.0097 0.013 0.018] 
k 10  tol 1e-06:   44 sec  eigvals [0 3.4e-06 2.8e-05 8.1e-05 0.00015 0.00025 0.00044 0.00058 0.00079 0.0011] 
k 10  tol 1e-07:  348 sec  eigvals [0 3e-10 7.5e-07 7.6e-06 1.2e-05 1.9e-05 2.1e-05 4.2e-05 5.7e-05 6.4e-05] 

k 20  tol 1e-05:   18 sec  eigvals [0 5.1e-06 4.5e-05 0.00014 0.00023 0.00042 0.00056 0.00079 0.0011 0.0015 0.0017 0.0021 0.0026 0.003 0.0037 0.0042 0.0047 0.0054 0.006
k 20  tol 1e-06:   73 sec  eigvals [0 5.5e-07 7.4e-06 2e-05 3.5e-05 5.1e-05 6.8e-05 0.00011 0.00014 0.00016 0.0002 0.00025 0.00027 0.0004 0.00045 0.00051 0.00057 0.00066
k 20  tol 1e-07:  267 sec  eigvals [-4.8e-11 0 7.5e-07 7.6e-06 1e-05 1.9e-05 2e-05 2.2e-05 4.2e-05 5.1e-05 5.8e-05 6.4e-05 6.9e-05 8.3e-05 0.00011 0.00012 0.00013 0.00015

k 50  tol 1e-05:   82 sec  eigvals [-4e-13 9.7e-07 1e-05 2.8e-05 5.9e-05 0.00011 0.00015 0.00019 0.00026 0.00039 ... 0.0079 0.0083 0.0087 0.0092 0.0096 0.01 0.011 0.011 0.012
k 50  tol 1e-06:  432 sec  eigvals [-1.4e-11 -4e-13 7.5e-07 7.6e-06 1e-05 1.9e-05 2e-05 2.2e-05 4.2e-05 5.1e-05 ... 0.00081 0.00087 0.00089 0.00096 0.001 0.001 0.0011 0.0011
k 50  tol 1e-07: 3711 sec  eigvals [-5.2e-10 -4e-13 7.5e-07 7.6e-06 1e-05 1.9e-05 2e-05 2.2e-05 4.2e-05 5.1e-05 ... 0.00058 0.0006 0.00063 0.00066 0.00069 0.00071 0.00075

versions: numpy 1.18.1  scipy 1.4.1  umfpack 0.3.2  python 3.7.6  mac 10.10.5 

Matlab / Octave примерно одинаковы? Если нет, все ставки выключены - сначала проверьте правильность, затем скорость.

Почему собственные значения так сильно колеблются? Крошечные <0 для предположительно неотрицательно определенной матрицы являются признаком ошибки округления , но обычный трюк с небольшим сдвигом A += n * eps * sparse.eye(n)не помогает.

Надеюсь это поможет.

Я знаю, что сейчас это старо, но у меня была та же проблема. Вы просматривали здесь ( https://docs.scipy.org/doc/scipy/reference/tutorial/arpack.html )?

Кажется, что когда вы устанавливаете сигма на низкое число (0), вы должны установить, который = 'LM', даже если вы хотите низкие значения. Это связано с тем, что настройка sigma преобразует значения, которые вы хотите (в данном случае, низкими), в высокие, и поэтому вы все еще можете использовать методы LM, которые намного быстрее получают то, что вы хотите (низкие собственные значения) ).

Сначала я хочу сказать, что понятия не имею, почему результаты, о которых вы и @Bill сообщили, такие, какие они есть. Мне просто интересно, соответствует ли eigs(M,6,0)Октава k=6 & sigma=0, или, может быть, это что-то еще?

С помощью scipy, если я не предоставлю сигму, я смогу получить результат за приемлемое время.

import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.linalg import eigsh
from time import perf_counter
M = np.load('M.npz')
a = csr_matrix((M['data'], M['indices'], M['indptr']), shape=M['shape'])
t = perf_counter()
b, c = eigsh(a, k=50, which='SA', tol=1e1)
print(perf_counter() - t)
print(b)

Я совершенно не уверен, имеет ли это смысл.

0.4332823531003669
[4.99011753e-03 3.32467891e-02 8.81752215e-02 1.70463893e-01
 2.80811313e-01 4.14752072e-01 5.71103821e-01 7.53593653e-01
 9.79938915e-01 1.14003837e+00 1.40442848e+00 1.66899183e+00
 1.96461415e+00 2.29252666e+00 2.63050114e+00 2.98443218e+00
 3.38439528e+00 3.81181747e+00 4.26309942e+00 4.69832271e+00
 5.22864462e+00 5.74498014e+00 6.22743988e+00 6.83904055e+00
 7.42379697e+00 7.97206446e+00 8.62281827e+00 9.26615266e+00
 9.85483434e+00 1.05915030e+01 1.11986296e+01 1.18934953e+01
 1.26811461e+01 1.33727614e+01 1.41794599e+01 1.47585155e+01
 1.55702295e+01 1.63066947e+01 1.71564622e+01 1.78260727e+01
 1.85693454e+01 1.95125277e+01 2.01847294e+01 2.09302671e+01
 2.18860389e+01 2.25424795e+01 2.32907153e+01 2.37425085e+01
 2.50784800e+01 2.55119112e+01]

Единственный способ найти сигма и получить результат за приемлемое время - это предоставить M в качестве линейного оператора. Я не слишком знаком с этой вещью, но из того, что я понял, моя реализация представляет собой матрицу идентичности, которая должна быть M, если она не указана в вызове. Причина этого в том, что вместо выполнения прямого решения (декомпозиции LU), scipy будет использовать итерационный решатель, который потенциально лучше подходит. Для сравнения, если вы предоставите M = np.identity(a.shape[0]), что должно быть точно так же, то eigsh всегда будет приносить результат. Обратите внимание, что этот подход не работает, если sigma=0он предусмотрен. Но я не уверен, sigma=0действительно ли это полезно?

import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.linalg import eigs, eigsh, LinearOperator
from time import perf_counter


def mv(v):
    return v


M = np.load('M.npz')
a = csr_matrix((M['data'], M['indices'], M['indptr']), shape=M['shape'])
t = perf_counter()
b, c = eigsh(a, M=LinearOperator(shape=a.shape, matvec=mv, dtype=np.float64),
             sigma=5, k=50, which='SA', tol=1e1, mode='cayley')
print(perf_counter() - t)
print(np.sort(-5 * (1 + b) / (1 - b)))

Опять же, не знаю, если это правильно, но определенно отличается от ранее. Было бы замечательно, если бы кто-то из Сципи сделал свой вклад.

1.4079377939924598
[3.34420263 3.47938816 3.53019328 3.57981026 3.60457277 3.63996294
 3.66791416 3.68391585 3.69223712 3.7082205  3.7496456  3.76170023
 3.76923989 3.80811939 3.81337342 3.82848729 3.84137264 3.85648208
 3.88110869 3.91286153 3.9271108  3.94444577 3.97580798 3.98868207
 4.01677424 4.04341426 4.05915855 4.08910692 4.12238969 4.15283192
 4.16871081 4.1990492  4.21792125 4.24509036 4.26892806 4.29603036
 4.32282475 4.35839271 4.37934257 4.40343219 4.42782208 4.4477206
 4.47635849 4.51594603 4.54294049 4.56689989 4.58804775 4.59919363
 4.63700551 4.66638214]