Wie viel Regularisierung muss hinzugefügt werden, um SVD stabil zu machen?

Ich habe die SVD von Intel MKL ( dgesvdüber SciPy) verwendet und festgestellt, dass die Ergebnisse erheblich voneinander abweichen, wenn ich die Genauigkeit zwischen float32und float64wenn meine Matrix schlecht konditioniert ist / nicht den vollen Rang hat. Gibt es einen Leitfaden zum Mindestmaß an Regularisierung, das ich hinzufügen sollte, um die Ergebnisse unempfindlich gegenüber float32-> float64Änderungen zu machen?

Insbesondere wenn ich mache , sehe ich, dass sich die L ∞ -Norm von V T X um ungefähr 1 bewegt, wenn ich die Genauigkeit zwischen und ändere . Die L 2 -Norm von A ist 10 5 und hat ungefähr 200 Null-Eigenwerte von insgesamt 784.$A=UDV^{T}$$L_\infty$$V^{T}X$float32float64$L_2$$A$$10^5$

Durch SVD auf mit λ = 10 - 3 verschwand der Unterschied.$\lambda I + A$$\lambda=10^{-3}$

Obwohl die Frage eine gute Antwort hat, ist hier eine Faustregel für kleine Singularwerte mit einer Darstellung.

$N$$\epsilon$

$\qquad$- Numerische Rezepte p. 795

Hinzugefügt: Die folgenden Zeilen berechnen diese Faustregel.

#!/usr/bin/env python2

from __future__ import division
import numpy as np
from scipy.sparse.linalg import svds  # sparse, dense or LinOp

#...............................................................................
def howsmall( A, singmax=None ):
    """ singular values < N float_eps sing_max  may be iffy, questionable
        "How small is small ?"
        [Numerical Recipes p. 795](http://apps.nrbook.com/empanel/index.html?pg=795)
    """
        # print "%d singular values are small, iffy" % (sing < howsmall(A)).sum()
        # small |eigenvalues| too ?
    if singmax is None:
        singmax = svds( A, 1, return_singular_vectors=False )[0]  # v0=random

    return max( A.shape ) * np.finfo( A.dtype ).eps * singmax

---

Die Hilbert-Matrix scheint als Testfall für Rundungsfehler weit verbreitet zu sein:

Hier Bits niedriger Ordnung in die Mantissen der Hilbert - Matrix werden auf Null gesetzt, A.astype(np.float__).astype(np.float64)und dann np.linalg.svdzulaufen float64. (Die Ergebnisse sind bei svdallen float32ungefähr gleich.)

Das einfache Abschneiden auf float32kann sogar nützlich sein, um hochdimensionale Daten zu entrauschen, z. B. für die Zug- / Testklassifizierung.

Echte Testfälle wären willkommen.

$A=A^{T}$$M=U \Sigma V^T$

$$H=\begin{bmatrix}0 & M\\ M^{T} & 0 \end{bmatrix}=\begin{bmatrix}U & 0\\ 0 & V \end{bmatrix}\begin{bmatrix}0 & \Sigma\\ \Sigma & 0 \end{bmatrix}\begin{bmatrix}U & 0\\ 0 & V \end{bmatrix}^{T}$$

$\epsilon>0$

$$A_{\epsilon}=\begin{bmatrix}1 & \epsilon\\ \epsilon & 1 \end{bmatrix}=V\Lambda_{\epsilon}V^{T},\qquad B_{\epsilon}=\begin{bmatrix}1+\epsilon & 0\\ 0 & 1-\epsilon \end{bmatrix}=U\Lambda_{\epsilon}U^{T}$$ $\Lambda_{\epsilon}=\mathrm{diag}(1+\epsilon,1-\epsilon)$ $$V=\frac{1}{\sqrt{2}}\begin{bmatrix}1 & 1\\ 1 & -1 \end{bmatrix},\qquad U=\begin{bmatrix}1 & 0\\ 0 & 1 \end{bmatrix}.$$ $A_{\epsilon} \approx B_{\epsilon}$$V$$U$$\epsilon>0$$U,V$$U\approx V$

$M_{0}=U_{0}\Sigma_{0}V_{0}^{T}$float64$M_{\epsilon}=U_{\epsilon}\Sigma_{\epsilon}V_{\epsilon}^{T}$float32$\Sigma_{0},\Sigma_{\epsilon}$$\epsilon\approx10^{-7}$$U_{0},U_{\epsilon}$$V_{0},V_{\epsilon}$