Xoay các thành phần PCA để cân bằng phương sai trong từng thành phần

Tôi đang cố gắng giảm tính chiều và tiếng ồn của bộ dữ liệu bằng cách thực hiện PCA trên bộ dữ liệu và loại bỏ vài PC cuối cùng. Sau đó, tôi muốn sử dụng một số thuật toán học máy trên các PC còn lại và do đó tôi muốn bình thường hóa dữ liệu bằng cách cân bằng phương sai của PC để làm cho thuật toán hoạt động tốt hơn.

Một cách đơn giản là đơn giản hóa bình thường phương sai thành các giá trị đơn vị. Tuy nhiên, PC đầu tiên chứa nhiều phương sai so với tập dữ liệu gốc so với các tập dữ liệu sau và tôi vẫn muốn cho nó nhiều "trọng lượng" hơn. Vì vậy, tôi đã tự hỏi: có một cách đơn giản để chỉ phân chia phương sai của nó và chia sẻ nó với các PC có ít phương sai hơn?

Một cách khác là ánh xạ các PC trở lại không gian tính năng ban đầu, nhưng trong trường hợp đó, tính chiều cũng sẽ tăng lên giá trị ban đầu.

Tôi đoán tốt hơn là giữ các cột kết quả trực giao, nhưng không cần thiết tại thời điểm này.

Tôi không hoàn toàn rõ ràng rằng những gì bạn đang hỏi là những gì bạn thực sự cần: một bước tiền xử lý phổ biến trong học máy là giảm kích thước + làm trắng, có nghĩa là thực hiện PCA và chuẩn hóa các thành phần, không có gì khác. Nhưng tôi vẫn sẽ tập trung vào câu hỏi của bạn vì nó được xây dựng, bởi vì nó thú vị hơn.

---

Đặt là ma trận dữ liệu trung tâm với các điểm dữ liệu trong các hàng và các biến trong các cột. PCA tương đương với phân tách giá trị số ít trong đó để thực hiện giảm kích thước, chúng tôi chỉ giữ các thành phần . Một "xoay nhân tố" trực giao của các thành phần này ngụ ý chọn một ma trận trực giao matrix và cắm nó vào phân tách:$\mathbf X$X = U S V ⊤ ≈ U k S k V ⊤ k , k k × k R X ≈ U k S k V ⊤ k = U k R R ⊤ S k V ⊤ k = $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$ $$\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}.$$ Ở đây là các thành phần được tiêu chuẩn hóa xoay và thuật ngữ thứ hai đại diện cho tải trọng xoay được chuyển đổi. Phương sai của mỗi thành phần sau khi quay được tính bằng tổng bình phương của vectơ tải tương ứng; trước khi quay, nó chỉ đơn giản là . Sau khi xoay nó là một cái gì đó khác.s 2 i /(n-1$\sqrt{n-1}\mathbf U_k \mathbf R$$s_i^2/(n-1)$

Bây giờ chúng tôi đã sẵn sàng để giải quyết vấn đề bằng thuật ngữ toán học: đưa ra các tải không được bảo vệ , tìm ma trận xoay sao cho các tải được xoay, , có tổng bình phương bằng nhau trong mỗi cột. RL$\mathbf L = \mathbf V_k \mathbf S_k / \sqrt{n-1}$$\mathbf R$$\mathbf L \mathbf R$

Hãy giải quyết nó. Tổng các cột của hình vuông sau khi quay bằng các phần tử đường chéo của

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

Tôi không nghĩ có một giải pháp dạng kín cho vấn đề này và trên thực tế có nhiều giải pháp khác nhau. Nhưng một giải pháp có thể dễ dàng được xây dựng theo kiểu liên tiếp:

1. $k$$\sigma_\text{max}>\mu$$\sigma_\text{min}<\mu$
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. $\mu$
4. Tiếp tục với cặp tiếp theo, lấy thành phần có phương sai lớn nhất và thành phần có phương sai nhỏ nhất. Đi số 2.

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

---

Thí dụ

$\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. Làm xong.

Tôi đã viết kịch bản Matlab thực hiện thuật toán này (xem bên dưới). Đối với ma trận đầu vào này, chuỗi các góc quay là:

48.1897   35.2644   45.0000

Phương sai thành phần sau mỗi bước (theo hàng):

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

Ma trận xoay vòng cuối cùng (sản phẩm của ba ma trận xoay 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

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

Đây là mã:

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

Đây là mã trong Python được cung cấp bởi @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

---

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

nhưng chưa chứng minh được phương trình này đến từ đâu; có lẽ nghĩ rằng nó là hiển nhiên mà không cần giải thích. Rõ ràng hay không, tôi tin rằng nó đáng để làm sáng tỏ - một cách nào đó. Câu trả lời của tôi trình bày một cách.

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

Nếu tôi diễn giải mọi thứ một cách chính xác, bạn có nghĩa là thành phần nguyên tắc đầu tiên (eigenvalue) giải thích hầu hết các phương sai trong dữ liệu. Điều này có thể xảy ra khi phương pháp nén của bạn là tuyến tính. Tuy nhiên, có thể có các phụ thuộc phi tuyến tính trong không gian tính năng của bạn.

TL / DR: PCA là phương pháp tuyến tính. Sử dụng Autoencoder (pca phi tuyến tính) để giảm kích thước. Nếu phần học máy được giám sát việc học thì chỉ cần theo dõi chức năng mất của bạn trong khi điều chỉnh các tham số (siêu) cho bộ mã hóa tự động. Bằng cách này, bạn sẽ kết thúc với một phiên bản nén dữ liệu gốc tốt hơn nhiều.

Đây là một ví dụ điển hình trong đó họ thực hiện tìm kiếm dạng lưới để tìm số lượng thành phần chính tối ưu để giữ (siêu tham số) bằng PCA. Cuối cùng, họ áp dụng Hồi quy logistic trên không gian chiều thấp hơn: http://scikit-learn.org/urdy/auto_examples/plot_digits_pipe.html#example-plot-digits-pipe-py

Protip: Bộ tạo tự động không có giải pháp dạng đóng (afaik) vì vậy nếu ngữ cảnh của bạn đang truyền dữ liệu, điều này có nghĩa là bạn có thể liên tục cập nhật bộ mã hóa tự động (biểu diễn nén) và do đó có thể bù cho những thứ như khái niệm trôi. Với pca, bạn phải đào tạo lại chế độ hàng loạt theo thời gian khi dữ liệu mới xuất hiện.

Để cung cấp cho một số tính năng "trọng lượng" hơn, hãy xem chính quy (Tôi sẽ bắt đầu từ định mức https://en.wikipedia.org/wiki/Norm_(mathatures) ). Bạn cũng có thể ngạc nhiên khi hồi quy logistic tương tự như thế nào với perceptron.