svds(solver=’lobpcg’)#

scipy.sparse.linalg.svds(A, k=6, ncv=None, tol=0, which='LM', v0=None, maxiter=None, return_singular_vectors=True, solver='arpack', rng=None, options=None)

Partielle Singulärwertzerlegung einer dünnbesetzten Matrix mittels LOBPCG.

Berechnet die größten oder kleinsten k Singulärwerte und die zugehörigen Singulärvektoren einer dünnbesetzten Matrix A. Die Reihenfolge, in der die Singulärwerte zurückgegeben werden, ist nicht garantiert.

In den folgenden Beschreibungen sei M, N = A.shape.

Parameter:
Adünnbesetzte Matrix oder LinearOperator

Zu zerlegende Matrix.

kint, Standardwert: 6

Anzahl der zu berechnenden Singulärwerte und Singulärvektoren. Muss 1 <= k <= min(M, N) - 1 erfüllen.

ncvint, optional

Ignoriert.

tolfloat, optional

Toleranz für Singulärwerte. Null (Standardwert) bedeutet Maschinengenauigkeit.

which{‘LM’, ‘SM’}

Welche k Singulärwerte gefunden werden sollen: entweder die mit der größten Magnitude (‘LM’) oder die mit der kleinsten Magnitude (‘SM’) Singulärwerte.

v0ndarray, optional

Wenn k gleich 1 ist, der Startvektor für die Iteration: ein (ungefährer) linker Singulärvektor, falls N > M, und ein rechter Singulärvektor andernfalls. Muss die Länge min(M, N) haben. Andernfalls ignoriert. Standard: zufällig

maxiterint, Standardwert: 20

Maximale Anzahl von Iterationen.

return_singular_vectors{True, False, “u”, “vh”}

Singulärwerte werden immer berechnet und zurückgegeben; dieser Parameter steuert die Berechnung und Rückgabe von Singulärvektoren.

  • True: Singulärvektoren zurückgeben.

  • False: keine Singulärvektoren zurückgeben.

  • "u": Wenn M <= N, nur die linken Singulärvektoren berechnen und None für die rechten Singulärvektoren zurückgeben. Andernfalls alle Singulärvektoren berechnen.

  • "vh": Wenn M > N, nur die rechten Singulärvektoren berechnen und None für die linken Singulärvektoren zurückgeben. Andernfalls alle Singulärvektoren berechnen.

solver{‘arpack’, ‘propack’, ‘lobpcg’}, optional

Dies ist die Solver-spezifische Dokumentation für solver='lobpcg'. ‘arpack’ und ‘propack’ werden ebenfalls unterstützt.

rngnumpy.random.Generator, optional

Zustand des pseudozufälligen Zahlengenerators. Wenn rng None ist, wird ein neuer numpy.random.Generator unter Verwendung der Entropie des Betriebssystems erstellt. Typen außer numpy.random.Generator werden an numpy.random.default_rng übergeben, um einen Generator zu instanziieren.

optionsdict, optional

Ein Wörterbuch mit Solver-spezifischen Optionen. Derzeit werden keine Solver-spezifischen Optionen unterstützt; dieser Parameter ist für die zukünftige Verwendung reserviert.

Rückgabe:
undarray, Form=(M, k)

Unitäre Matrix mit linken Singulärvektoren als Spalten.

sndarray, Form=(k,)

Die Singulärwerte.

vhndarray, Form=(k, N)

Unitäre Matrix mit rechten Singulärvektoren als Zeilen.

Hinweise

Dies ist eine naive Implementierung, die LOBPCG als Eigenlöser auf A.conj().T @ A oder A @ A.conj().T verwendet, je nachdem, was effizienter ist.

Beispiele

Erstellt eine Matrix A aus Singulärwerten und -vektoren.

>>> import numpy as np
>>> from scipy.stats import ortho_group
>>> from scipy.sparse import csc_array, diags_array
>>> from scipy.sparse.linalg import svds
>>> rng = np.random.default_rng()
>>> orthogonal = csc_array(ortho_group.rvs(10, random_state=rng))
>>> s = [0.0001, 0.001, 3, 4, 5]  # singular values
>>> u = orthogonal[:, :5]         # left singular vectors
>>> vT = orthogonal[:, 5:].T      # right singular vectors
>>> A = u @ diags_array(s) @ vT

Mit nur drei Singulärwerten/-vektoren approximiert die SVD die ursprüngliche Matrix.

>>> u2, s2, vT2 = svds(A, k=3, solver='lobpcg')
>>> A2 = u2 @ np.diag(s2) @ vT2
>>> np.allclose(A2, A.toarray(), atol=1e-3)
True

Mit allen fünf Singulärwerten/-vektoren können wir die ursprüngliche Matrix reproduzieren.

>>> u3, s3, vT3 = svds(A, k=5, solver='lobpcg')
>>> A3 = u3 @ np.diag(s3) @ vT3
>>> np.allclose(A3, A.toarray())
True

Die Singulärwerte stimmen mit den erwarteten Singulärwerten überein, und die Singulärvektoren sind bis auf einen Vorzeichenunterschied wie erwartet.

>>> (np.allclose(s3, s) and
...  np.allclose(np.abs(u3), np.abs(u.todense())) and
...  np.allclose(np.abs(vT3), np.abs(vT.todense())))
True

Die Singulärvektoren sind ebenfalls orthogonal.

>>> (np.allclose(u3.T @ u3, np.eye(5)) and
...  np.allclose(vT3 @ vT3.T, np.eye(5)))
True