Putar komponen PCA untuk menyamakan varians di setiap komponen

Saya mencoba mengurangi dimensi dan derau dataset dengan melakukan PCA pada dataset dan membuang beberapa PC terakhir. Setelah itu, saya ingin menggunakan beberapa algoritma pembelajaran mesin pada PC yang tersisa, dan karena itu saya ingin menormalkan data dengan menyamakan varians PC untuk membuat algoritma bekerja lebih baik.

Satu cara sederhana adalah dengan hanya menormalkan varians ke nilai unit. Namun, PC pertama berisi lebih banyak varians dari dataset asli daripada yang berikut, dan saya masih ingin memberikan lebih banyak "bobot". Karena itu saya bertanya-tanya: adakah cara sederhana untuk hanya memisahkan variansnya dan membaginya dengan PC dengan varian yang lebih sedikit?

Cara lain adalah memetakan PC kembali ke ruang fitur asli, tetapi dalam hal itu dimensi juga akan meningkat ke nilai aslinya.

Saya kira lebih baik untuk menjaga kolom yang dihasilkan ortogonal, tetapi itu tidak perlu saat ini.

Tidak sepenuhnya jelas bagi saya bahwa apa yang Anda tanyakan adalah apa yang benar-benar Anda butuhkan: langkah preprocessing yang umum dalam pembelajaran mesin adalah pengurangan dimensi + pemutihan, yang berarti melakukan PCA dan menstandarisasi komponen, tidak ada yang lain. Tetapi saya akan tetap fokus pada pertanyaan Anda seperti yang dirumuskan, karena itu lebih menarik.

---

Biarkan menjadi pusat data matriks dengan titik data dalam baris dan variabel dalam kolom. PCA sama dengan dekomposisi nilai singular mana untuk melakukan pengurangan dimensionalitas kita hanya menyimpan komponen . "Rotasi faktor" ortogonal dari komponen-komponen ini menyiratkan memilih ortogonal matrix dan menghubungkannya ke dalam dekomposisi: n × d X = U S V ⊤ ≈ U k S k V ⊤ $\mathbf X$$n\times d$k k × k R X ≈ U k S k V ⊤ k = U k R R ⊤ S k V ⊤ k =

$$\mathbf X = \mathbf{USV}^\top \approx \mathbf U_k \mathbf S_k \mathbf V_k^\top,$$ $k$$k \times k$$\mathbf R$ $$\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}.$$ Di sini adalah komponen yang diputar standar dan istilah kedua mewakili pemuatan yang diputar ditransformasikan. Varians setiap komponen setelah rotasi diberikan oleh jumlah kuadrat dari vektor pemuatan yang sesuai; sebelum rotasi, cukup . Setelah rotasi itu adalah hal lain.s 2 i /(n-1$\sqrt{n-1}\mathbf U_k \mathbf R$$s_i^2/(n-1)$

Sekarang kita siap untuk merumuskan masalah dalam istilah matematika: diberikan pembebanan yang tidak diputar , cari matriks rotasi sedemikian rupa sehingga pembebanan yang diputar, , memiliki jumlah kuadrat yang sama di setiap kolom. RL$\mathbf L = \mathbf V_k \mathbf S_k / \sqrt{n-1}$$\mathbf R$$\mathbf L \mathbf R$

Mari kita selesaikan. Jumlah kolom kuadrat setelah rotasi sama dengan elemen diagonal Ini masuk akal: rotasi hanya mendistribusikan ulang varian komponen, yang awalnya diberikan oleh , di antara mereka, sesuai dengan rumus ini. Kita perlu mendistribusikannya kembali sehingga semuanya menjadi sama dengan nilai rata-rata mereka .s 2 i /(n-1)

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

Saya tidak berpikir ada solusi bentuk tertutup untuk ini, dan sebenarnya ada banyak solusi berbeda. Tetapi solusi dapat dengan mudah dibangun secara berurutan:

1. Ambil komponen pertama dan komponen -th. Yang pertama memiliki varians dan yang terakhir memiliki varians .σ maks > μ σ min < $k$$\sigma_\text{max}>\mu$$\sigma_\text{min}<\mu$
2. Putar hanya dua ini sehingga varians yang pertama menjadi sama dengan . Matriks rotasi dalam 2D ​​hanya bergantung pada satu parameter dan mudah untuk menuliskan persamaan dan menghitung diperlukan . Memang, dan setelah transformasi PC pertama akan mendapatkan varians dari sana kita segera memperolehθ θ R 2D = ( cos θ sin θ - sin θ cos θ ) cos 2$\mu$$\theta$$\theta$ $$\mathbf R_\text{2D} = \left(\begin{array}{cc}\cos \theta & \sin \theta \\ -\sin\theta & \cos \theta\end{array}\right)$$ $$\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. Komponen pertama sekarang selesai, ia memiliki varian .$\mu$
4. Lanjutkan ke pasangan berikutnya, mengambil komponen dengan varian terbesar dan satu dengan varian terkecil. Goto # 2.

Ini akan mendistribusikan ulang semua varian secara merata dengan urutan rotasi 2D. Mengalikan semua matriks rotasi ini bersama-sama akan menghasilkan keseluruhan .$(k-1)$$\mathbf R$

---

Contoh

Pertimbangkan matriks :Varians rata-rata adalah . Algoritme saya akan diproses sebagai berikut:$\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. Langkah 1: putar PC1 dan PC4 sehingga PC1 mendapat varian . Akibatnya, PC4 mendapat varians .$5$$1+(10-5)=6$

2. Langkah 2: putar PC2 (varian maksimal baru) dan PC3 sehingga PC2 mendapatkan varian . Akibatnya, PC3 mendapat varians .$5$$3+(6-5)=4$

3. Langkah 3: putar PC4 (varian maksimal baru) dan PC3 sehingga PC4 mendapatkan varian . Akibatnya, PC3 mendapat varians .4 + ( 6 - 1 ) = $5$$4+(6-1)=5$

4. Selesai

Saya menulis skrip Matlab yang mengimplementasikan algoritma ini (lihat di bawah). Untuk matriks input ini, urutan sudut rotasi adalah:

48.1897   35.2644   45.0000

Varians komponen setelah setiap langkah (dalam baris):

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

Matriks rotasi akhir (produk dari tiga matriks rotasi 2D):

 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

Dan matriks terakhir adalah:$(\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

Ini kodenya:

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

Berikut adalah kode dalam Python yang disediakan oleh @feilong:

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

---

Perhatikan bahwa masalah ini benar-benar setara dengan yang berikut: diberikan variabel tidak berkorelasi dengan varians , temukan rotasi (yaitu basis ortogonal baru) yang akan menghasilkan variabel dengan varians yang sama (tetapi tentu saja tidak berkorelasi lagi).σ 2 i$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})$$

tetapi belum menunjukkan dari mana persamaan ini berasal; mungkin berpikir bahwa itu jelas tanpa penjelasan. Jelas atau tidak, saya percaya itu layak dijelaskan - dengan cara tertentu. Jawaban saya menyajikan satu cara.

$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$

Jika saya menginterpretasikan hal-hal dengan benar, maksud Anda bahwa komponen prinsip pertama (nilai eigen) menjelaskan sebagian besar varian dalam data. Ini dapat terjadi ketika metode kompresi Anda linier. Namun, mungkin ada dependensi non-linear di ruang fitur Anda.

TL / DR: PCA adalah metode linier. Gunakan Autoencoder (pca non-linear) untuk pengurangan dimensi. Jika bagian pembelajaran mesin adalah pembelajaran yang diawasi, maka cukup pantau fungsi kerugian Anda sambil menyesuaikan parameter (hiper) untuk autoencoder. Dengan cara ini Anda akan mendapatkan versi terkompresi yang lebih baik dari data asli Anda.

Berikut ini adalah contoh scikit di mana mereka melakukan pencarian grid untuk menemukan jumlah optimal komponen utama yang harus disimpan (hyper-parameter) menggunakan PCA. Akhirnya mereka menerapkan Regresi Logistik di ruang dimensi bawah: http://scikit-learn.org/stable/auto_examples/plot_digits_pipe.html#example-plot-digits-pipe-py

Protip: Autoencoder tidak memiliki solusi bentuk tertutup (afaik) jadi jika konteks Anda adalah streaming data, ini berarti Anda dapat terus memperbarui autencoder Anda (representasi terkompresi) dan dengan demikian dapat mengkompensasi hal-hal seperti penyimpangan konsep. Dengan pca, Anda harus melatih kembali mode batch dari waktu ke waktu saat data baru masuk.

Untuk memberi beberapa fitur lebih "berat", lihat regularisasi (saya akan mulai dari norma https://en.wikipedia.org/wiki/Norm_(mathematics) ). Anda mungkin juga terkejut betapa miripnya regresi logistik dengan perceptron.