Drehen Sie die PCA-Komponenten, um die Varianz in jeder Komponente auszugleichen

Ich versuche, die Dimensionalität und das Rauschen eines Datensatzes zu reduzieren, indem ich eine PCA für den Datensatz durchführe und die letzten PCs wegwerfe. Danach möchte ich einige Algorithmen für maschinelles Lernen auf den verbleibenden PCs verwenden und daher die Daten normalisieren, indem ich die Varianz der PCs anpasse, damit die Algorithmen besser funktionieren.

Eine einfache Möglichkeit besteht darin, die Varianz einfach auf Einheitswerte zu normalisieren. Der erste PC enthält jedoch mehr Abweichungen vom ursprünglichen Datensatz als die folgenden, und ich möchte ihm immer noch mehr "Gewicht" geben. Deshalb habe ich mich gefragt: Gibt es eine einfache Möglichkeit, die Varianz einfach aufzuteilen und mit weniger Abweichungen an die PCs weiterzugeben?

Eine andere Möglichkeit besteht darin, die PCs wieder dem ursprünglichen Merkmalsraum zuzuordnen. In diesem Fall würde sich jedoch auch die Dimensionalität auf den ursprünglichen Wert erhöhen.

Ich denke, es ist besser, die resultierenden Spalten orthogonal zu halten, aber es ist im Moment nicht notwendig.

Mir ist nicht ganz klar, dass Sie fragen, was Sie wirklich brauchen: Ein üblicher Vorverarbeitungsschritt beim maschinellen Lernen ist die Reduzierung der Dimensionalität + das Aufhellen, was bedeutet, PCA durchzuführen und die Komponenten zu standardisieren, sonst nichts. Aber ich werde mich trotzdem auf Ihre Frage konzentrieren, wie sie formuliert ist, weil sie interessanter ist.

---

Sei die zentrierte n × d- Datenmatrix mit Datenpunkten in Zeilen und Variablen in Spalten. PCA beträgt Singulärwertzergliederung X = U S V ⊤ ≈ U k S k V ⊤ k , wo die Dimensionsreduktion halten wir nur auszuführen k Komponenten. Eine orthogonale "Faktorrotation" dieser Komponenten impliziert die Auswahl einer orthogonalen k × k- Matrix R und deren Einfügung in die Zerlegung: X ≈ U k S k $\mathbf X$$n\times d$

$$\mathbf X = \mathbf{USV}^\top \approx \mathbf U_k \mathbf S_k \mathbf V_k^\top,$$ $k$$k \times k$$\mathbf R$Hier $$\mathbf X \approx \mathbf U_k \mathbf S_k \mathbf V_k^\top = \mathbf U_k \mathbf {RR}^\top \mathbf S_k \mathbf V_k^\top = \underbrace{\sqrt{n-1}\mathbf U_k^\phantom\top \mathbf {R}}_{\substack{\text{Rotated}\\\text{standardized scores}}} \cdot \underbrace{\mathbf R^\top \mathbf S_k \mathbf V_k^\top/\sqrt{n-1}}_{\text{Rotated loadings}^\top}.$$ sind gedrehte standardisierte Komponenten und der zweite Term repräsentiert gedrehte gedrehte Belastungen. Die Varianz jeder Komponente nach der Drehung ist durch die Summe der Quadrate des entsprechenden Ladevektors gegeben; vor der Drehung ist es einfachs 2 i /(n-1). Nach der Rotation ist es etwas anderes.$\sqrt{n-1}\mathbf U_k \mathbf R$$s_i^2/(n-1)$

Jetzt sind wir bereit, das Problem in mathematischen Begriffen zu formulieren: gegebene nicht gedrehte Belastungen , finde die RotationsmatrixRso, dass die gedrehten LadungenLRin jeder Spalte die gleiche Quadratsumme haben.$\mathbf L = \mathbf V_k \mathbf S_k / \sqrt{n-1}$$\mathbf R$$\mathbf L \mathbf R$

Lass es uns lösen. Spaltenquadratsummen nach der Drehung sind gleich den diagonalen Elementen von Dies ist sinnvoll: Durch Rotation werden einfach die Varianzen von Komponenten, die ursprünglich durchs 2 i /(n-1) gegebensind, gemäß dieser Formel zwischen ihnen neu verteilt. Wir müssen sie so umverteilen, dass sie alle gleich ihrem Durchschnittswertμ werden.

$$(\mathbf {LR})^\top \mathbf{LR} = \mathbf R^\top \frac{\mathbf S^2}{n-1} \mathbf R.$$ $s_i^2/(n-1)$$\mu$

Ich glaube nicht, dass es dafür eine geschlossene Lösung gibt, und tatsächlich gibt es viele verschiedene Lösungen. Eine Lösung kann jedoch leicht sequentiell erstellt werden:

1. Nehmen Sie die erste Komponente und die te Komponente. Der erste hat die Varianz σ max > μ und der letzte hat die Varianz σ min < μ .$k$$\sigma_\text{max}>\mu$$\sigma_\text{min}<\mu$
2. Drehen Sie nur diese beiden so, dass die Varianz der ersten gleich . Die Rotationsmatrix in 2D hängt nur von einem Parameter θ ab, und es ist einfach, die Gleichung aufzuschreiben und das erforderliche θ zu berechnen . Tatsächlich R 2D = ( cos θ sin θ - sin θ cos θ ) und nach der Transformation der erste PC erhalten Varianz cos 2 θ ⋅ & sgr; max + sin 2 θ ⋅ & sgr; min = cos 2 θ ⋅ $\mu$$\theta$$\theta$ $$\mathbf R_\text{2D} = \left(\begin{array}{cc}\cos \theta & \sin \theta \\ -\sin\theta & \cos \theta\end{array}\right)$$ woraus wir sofort cos 2 θ = μ - σ $$\cos^2\theta \cdot \sigma_\text{max} + \sin^2\theta \cdot \sigma_\text{min} = \cos^2\theta \cdot \sigma_\text{max} + (1-\cos^2\theta)\cdot \sigma_\text{min} =\mu,$$ $$\cos^2\theta = \frac{\mu-\sigma_\text{min}}{\sigma_\text{max}-\sigma_\text{min}}.$$
3. Die erste Komponente ist nun fertig, sie hat die Varianz .$\mu$
4. Fahren Sie mit dem nächsten Paar fort und nehmen Sie die Komponente mit der größten Varianz und die mit der kleinsten Varianz. Gehe zu # 2.

$(k-1)$$\mathbf R$

---

Beispiel

$\mathbf S^2/(n-1)$

$$\left(\begin{array}{cccc}10&0&0&0\\0&6&0&0\\0&0&3&0\\0&0&0&1\end{array}\right).$$ $5$

1. $5$$1+(10-5)=6$

2. $5$$3+(6-5)=4$

3. $5$$4+(6-1)=5$

4. Getan.

Ich habe das Matlab-Skript geschrieben, das diesen Algorithmus implementiert (siehe unten). Für diese Eingabematrix lautet die Folge der Drehwinkel:

48.1897   35.2644   45.0000

Komponentenabweichungen nach jedem Schritt (in Zeilen):

10     6     3     1
 5     6     3     6
 5     5     4     6
 5     5     5     5

Die endgültige Rotationsmatrix (Produkt aus drei 2D-Rotationsmatrizen):

 0.6667         0    0.5270    0.5270
      0    0.8165    0.4082   -0.4082
      0   -0.5774    0.5774   -0.5774
-0.7454         0    0.4714    0.4714

$(\mathbf{LR})^\top \mathbf{LR}$

5.0000         0    3.1623    3.1623
     0    5.0000    1.0000   -1.0000
3.1623    1.0000    5.0000    1.0000
3.1623   -1.0000    1.0000    5.0000

Hier ist der Code:

S = diag([10 6 3 1]);
mu = mean(diag(S));
R = eye(size(S));

vars(1,:) = diag(S);
Supdated = S;

for i = 1:size(S,1)-1
    [~, maxV] = max(diag(Supdated));
    [~, minV] = min(diag(Supdated));

    w = (mu-Supdated(minV,minV))/(Supdated(maxV,maxV)-Supdated(minV,minV));
    cosTheta = sqrt(w);
    sinTheta = sqrt(1-w);

    R2d = eye(size(S));
    R2d([maxV minV], [maxV minV]) = [cosTheta sinTheta; -sinTheta cosTheta];
    R = R * R2d;

    Supdated = transpose(R2d) * Supdated * R2d;    

    vars(i+1,:) = diag(Supdated);
    angles(i) = acosd(cosTheta);
end

angles                %// sequence of 2d rotation angles
round(vars)           %// component variances on each step
R                     %// final rotation matrix
transpose(R)*S*R      %// final S matrix

Hier ist der Code in Python, der von @feilong bereitgestellt wird:

def amoeba_rotation(s2):
    """
    Parameters
    ----------
    s2 : array
        The diagonal of the matrix S^2.

    Returns
    -------
    R : array
        The rotation matrix R.

    Examples
    --------
    >>> amoeba_rotation(np.array([10, 6, 3, 1]))
    [[ 0.66666667  0.          0.52704628  0.52704628]
     [ 0.          0.81649658  0.40824829 -0.40824829]
     [ 0.         -0.57735027  0.57735027 -0.57735027]
     [-0.74535599  0.          0.47140452  0.47140452]]

    http://stats.stackexchange.com/a/177555/87414
    """
    n = len(s2)
    mu = s2.mean()
    R = np.eye(n)
    for i in range(n-1):
        max_v, min_v = np.argmax(s2), np.argmin(s2)
        w = (mu - s2[min_v]) / (s2[max_v] - s2[min_v])
        cos_theta, sin_theta = np.sqrt(w), np.sqrt(1-w)
        R[:, [max_v, min_v]] = np.dot(
            R[:, [max_v, min_v]],
            np.array([[cos_theta, sin_theta], [-sin_theta, cos_theta]]))
        s2[[max_v, min_v]] = [mu, s2[max_v] + s2[min_v] - mu]
    return R

---

$k$$\sigma_i^2$$k$

$X$$Y$$\sigma^2_{max}$$\sigma^2_{min}$$X$$\mu^2$$Y$$\sigma^2_{max}+\sigma^2_{min}-\mu^2$

$\cos\theta$

$$\mu^2 = \cos^2\theta (\sigma^2_{max}) + \sin^2\theta (\sigma^2_{min})$$

hat aber nicht gezeigt, woher diese Gleichung kommt; wahrscheinlich denken, dass es ohne Erklärung offensichtlich ist. Offensichtlich oder nicht, ich glaube, es lohnt sich zu erklären - irgendwie. Meine Antwort zeigt einen Weg.

$X$$Y$$\theta$$X$$x$$x^*$

$x$ $X^*$$x'=x\cos\theta$$x^*$$x'$$x'-x^*$$y$$y\sin\theta$

$$x^* = x' - (x'-x^*) = x\cos\theta-y\sin\theta$$

$\mu^2$$X^*$

$$\mu^2=\sum x^{*2} = \sum(x\cos\theta-y\sin\theta)^2 = \sum(x^2\cos^2\theta+y^2\sin^2\theta-2xy\cos\theta\sin\theta) = \cos^2\theta\sum x^2 + \sin^2\theta\sum y^2 - \underbrace{ 2\cos\theta\sin\theta\sum xy}_{\text{=0 (X and Y are uncorrelated)}} = \cos^2\theta (\sigma^2_{max}) + \sin^2\theta (\sigma^2_{min})$$

$\cos\theta$

Wenn ich die Dinge richtig interpretiere, meinen Sie, dass die erste Hauptkomponente (Eigenwert) den größten Teil der Varianz in den Daten erklärt. Dies kann passieren, wenn Ihre Komprimierungsmethode linear ist. Möglicherweise gibt es jedoch nichtlineare Abhängigkeiten in Ihrem Feature-Space.

TL / DR: PCA ist eine lineare Methode. Verwenden Sie Autoencoder (nichtlineare pca) zur Reduzierung der Dimensionalität. Wenn der Teil des maschinellen Lernens überwacht wird, überwachen Sie einfach Ihre Verlustfunktion, während Sie die (Hyper-) Parameter für den Autoencoder anpassen. Auf diese Weise erhalten Sie eine weitaus besser komprimierte Version Ihrer Originaldaten.

Hier ist ein Scikit-Beispiel, in dem sie eine Rastersuche durchführen, um die optimale Anzahl von Hauptkomponenten zu finden, die mithilfe von PCA beibehalten werden sollen (Hyperparameter). Schließlich wenden sie die logistische Regression auf den unteren Dimensionsraum an: http://scikit-learn.org/stable/auto_examples/plot_digits_pipe.html#example-plot-digits-pipe-py

Protip: Autoencoder haben keine Closed-Form-Lösung (afaik). Wenn Ihr Kontext also Daten überträgt, können Sie Ihren Autoencoder kontinuierlich aktualisieren (komprimierte Darstellung) und so Dinge wie Konzeptdrift kompensieren. Mit pca müssen Sie den Batch-Modus von Zeit zu Zeit neu trainieren, wenn neue Daten eingehen.

Informationen zum "Gewicht" einiger Funktionen finden Sie unter Regularisierung (ich gehe von den Normen https://en.wikipedia.org/wiki/Norm_(mathematics aus ). Sie könnten auch überrascht sein, wie ähnlich die logistische Regression dem Perzeptron ist.