หมุนส่วนประกอบ PCA เพื่อปรับความแปรปรวนในแต่ละองค์ประกอบให้เท่ากัน

ฉันกำลังพยายามลดมิติข้อมูลและเสียงรบกวนของชุดข้อมูลด้วยการแสดง PCA บนชุดข้อมูลและทิ้งพีซีสองสามเครื่องล่าสุด หลังจากนั้นฉันต้องการใช้อัลกอริทึมการเรียนรู้ของเครื่องบางอย่างบนพีซีที่เหลืออยู่ดังนั้นฉันจึงต้องการทำให้ข้อมูลเป็นมาตรฐานด้วยการทำให้ความแตกต่างของพีซีให้เท่ากัน

วิธีง่ายๆวิธีหนึ่งก็คือทำให้ค่าความแปรปรวนเป็นค่าหน่วย อย่างไรก็ตามพีซีเครื่องแรกมีความแปรปรวนจากชุดข้อมูลดั้งเดิมมากกว่าชุดข้อมูลต่อไปนี้และฉันยังต้องการให้ "น้ำหนัก" มากขึ้น ดังนั้นฉันสงสัยว่า: มีวิธีง่าย ๆ ในการแยกความแปรปรวนและแบ่งปันกับพีซีที่มีความแปรปรวนน้อยกว่าหรือไม่

อีกวิธีหนึ่งคือการแมปพีซีกลับไปยังพื้นที่คุณลักษณะดั้งเดิม แต่ในกรณีนั้นมิติข้อมูลจะเพิ่มขึ้นเป็นค่าดั้งเดิม

ฉันเดาว่าจะดีกว่าที่จะเก็บคอลัมน์ผลลัพธ์ไว้เป็นมุมฉาก แต่ก็ไม่จำเป็นในตอนนี้

ยังไม่ชัดเจนสำหรับฉันว่าสิ่งที่คุณถามคือสิ่งที่คุณต้องการจริง ๆ : ขั้นตอนทั่วไปในการเรียนรู้ของเครื่องคือการลดขนาดและฟอกสีฟันซึ่งหมายถึงการทำ PCA และสร้างมาตรฐานให้กับองค์ประกอบ แต่ฉันจะยังคงให้ความสำคัญกับคำถามของคุณเนื่องจากเป็นสูตรที่น่าสนใจมากกว่า

---

ปล่อย $\mathbf X$ เป็นศูนย์กลาง $n\times d$เมทริกซ์ข้อมูลที่มีจุดข้อมูลในแถวและตัวแปรในคอลัมน์ PCA จะเท่ากับการสลายตัวของค่าเอกฐาน

$$\mathbf X = \mathbf{USV}^\top \approx \mathbf U_k \mathbf S_k \mathbf V_k^\top,$$ สถานที่เพื่อลดขนาดเราเก็บไว้เท่านั้น $k$ส่วนประกอบ orthogonal "การหมุนตัวประกอบปัจจัย" ขององค์ประกอบเหล่านี้แสดงถึงการเลือกมุมฉาก$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}.$$ ที่นี่ $\sqrt{n-1}\mathbf U_k \mathbf R$เป็นส่วนประกอบมาตรฐานที่หมุนได้และคำศัพท์ที่สองแสดงถึงการโหลดแบบหมุนเวียนที่ย้าย ความแปรปรวนของแต่ละองค์ประกอบหลังจากการหมุนถูกกำหนดโดยผลรวมของกำลังสองของเวกเตอร์การโหลดที่สอดคล้องกัน ก่อนการหมุน$s_i^2/(n-1)$. หลังจากหมุนมันเป็นอย่างอื่น

ตอนนี้เราพร้อมที่จะกำหนดปัญหาในแง่คณิตศาสตร์แล้ว: รับโหลดที่ไม่ได้รับการป้องกัน $\mathbf L = \mathbf V_k \mathbf S_k / \sqrt{n-1}$หาเมทริกซ์การหมุน $\mathbf R$ เช่นที่โหลดหมุน $\mathbf L \mathbf R$มีผลรวมกำลังสองเท่ากันในแต่ละคอลัมน์

มาแก้กัน ผลรวมของคอลัมน์ของช่องสี่เหลี่ยมหลังจากการหมุนจะเท่ากับองค์ประกอบในแนวทแยงของ

$$(\mathbf {LR})^\top \mathbf{LR} = \mathbf R^\top \frac{\mathbf S^2}{n-1} \mathbf R.$$ สิ่งนี้สมเหตุสมผล: การหมุนเพียงแค่กระจายความแปรปรวนของส่วนประกอบซึ่งได้รับมาจากเดิม $s_i^2/(n-1)$ระหว่างพวกเขาตามสูตรนี้ เราจำเป็นต้องแจกจ่ายต่อให้พวกเขาเหล่านั้นทั้งหมดเท่ากับมูลค่าเฉลี่ยของพวกเขา$\mu$.

ฉันไม่คิดว่าจะมีวิธีแก้ปัญหาแบบปิดนี้และอันที่จริงมีวิธีแก้ปัญหาที่แตกต่างกันมากมาย แต่วิธีการแก้ปัญหาสามารถสร้างได้อย่างง่ายดายตามลำดับ:

1. ใช้องค์ประกอบแรกและ $k$องค์ประกอบที่ คนแรกมีความแปรปรวน$\sigma_\text{max}>\mu$ และอันสุดท้ายมีความแปรปรวน $\sigma_\text{min}<\mu$.
2. หมุนสองอันนี้เท่านั้นเพื่อให้ความแปรปรวนของอันแรกเท่ากับ $\mu$. เมทริกซ์การหมุนใน 2D ขึ้นอยู่กับพารามิเตอร์เดียวเท่านั้น$\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. ดำเนินการต่อไปยังคู่ถัดไปนำส่วนประกอบที่มีความแปรปรวนที่ใหญ่ที่สุดและอันที่มีความแปรปรวนน้อยที่สุด ไปที่ # 2

สิ่งนี้จะกระจายผลต่างทั้งหมดเท่า ๆ กันตามลำดับ $(k-1)$การหมุนแบบ 2 มิติ การคูณเมทริกซ์การหมุนเหล่านี้ทั้งหมดเข้าด้วยกันจะให้ผลโดยรวม$\mathbf R$.

---

ตัวอย่าง

พิจารณาดังต่อไปนี้ $\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. ขั้นตอนที่ 1: หมุน PC1 และ PC4 เพื่อให้ PC1 ได้รับความแปรปรวน $5$. เป็นผลให้ PC4 ได้รับความแปรปรวน$1+(10-5)=6$.

2. ขั้นตอนที่ 2: หมุน PC2 (ความแปรปรวนสูงสุดใหม่) และ PC3 เพื่อให้ PC2 ได้รับความแปรปรวน $5$. เป็นผลให้ PC3 ได้รับความแปรปรวน$3+(6-5)=4$.

3. ขั้นตอนที่ 3: หมุน PC4 (ความแปรปรวนสูงสุดใหม่) และ PC3 เพื่อให้ PC4 ได้รับความแปรปรวน $5$. เป็นผลให้ PC3 ได้รับความแปรปรวน$4+(6-1)=5$.

4. เสร็จสิ้น

ฉันเขียนสคริปต์ Matlab ที่ใช้อัลกอริทึมนี้ (ดูด้านล่าง) สำหรับเมทริกซ์อินพุตนี้ลำดับของมุมการหมุนคือ:

48.1897   35.2644   45.0000

องค์ประกอบผลต่างหลังจากแต่ละขั้นตอน (ในแถว):

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

เมทริกซ์การหมุนรอบสุดท้าย (ผลิตภัณฑ์ของเมทริกซ์การหมุน 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

นี่คือรหัส:

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

นี่คือรหัสใน Python ให้บริการโดย @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$ ตัวแปรที่มีความแปรปรวนเท่ากัน (แต่แน่นอนว่าไม่ได้ไม่เกี่ยวข้องกันอีกต่อไป)

ในคำตอบที่ชาญฉลาดและครอบคลุมของเขา @amoeba ได้แสดงให้เห็นว่าเป็นส่วนหนึ่งของคำตอบ - วิธีที่เราสามารถหมุนตัวแปรที่ไม่เกี่ยวข้องสองตัว (เช่นองค์ประกอบหลักเช่น) เพื่อให้บรรลุความแปรปรวนที่ต้องการสำหรับพวกเขา . ขอตัวแปรมุมฉาก$X$ และ $Y$ มีความแปรปรวน $\sigma^2_{max}$ (ใหญ่กว่า) และ $\sigma^2_{min}$(เล็กกว่า) ตามลำดับ หมุนไปเรื่อย ๆ$X$ จะได้รับการแปรปรวนลดลงโดยพลการ $\mu^2$ (ในขณะที่ $Y$ดังนั้นจะกลายเป็นความแปรปรวน $\sigma^2_{max}+\sigma^2_{min}-\mu^2$)

@amoeba แสดงสูตรที่เราสามารถคำนวณมุมการหมุนได้ $\cos\theta$:

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

แต่ไม่ได้แสดงให้เห็นว่าสมการนี้มาจากไหน อาจคิดว่ามันชัดเจนโดยไม่มีคำอธิบาย ชัดเจนหรือไม่ฉันเชื่อว่ามันคุ้มค่าที่จะอธิบาย - บางวิธี คำตอบของฉันนำเสนอทางเดียว

ดังนั้นเรามีรูปวงรีข้อมูลที่เป็นศูนย์กลางในพื้นที่ของตัวแปรที่ไม่เกี่ยวข้อง $X$ และ $Y$. เราต้องหมุนแกนตามมุม$\theta$. จุดข้อมูลในคลาวด์ (เช่นแสดงเป็นจุดสีเขียวบนภาพ) ด้วย$X$ ประสานงาน $x$ จะมีพิกัดนี้เป็น $x^*$ หลังจากการหมุน

สังเกตว่าเส้นโครงของพิกัดนั้น $x$ บากบนแกนหมุน$X^*$ ได้รับจาก $x'=x\cos\theta$(cathetus เป็นด้านตรงข้ามมุมฉากและมุมระหว่างพวกเขา) สังเกตด้วยว่า$x^*$ น้อยกว่า $x'$ โดยการตัดความยาว $x'-x^*$ คำนวณได้จากการประสานงาน $y$: $y\sin\theta$(cathetus อื่นและด้านตรงข้ามมุมฉาก) และดังนั้น

$$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$, ตามที่ @amoeba แสดงขึ้นและทำการหมุน

ถ้าฉันตีความสิ่งต่าง ๆ ได้อย่างถูกต้องคุณหมายถึงองค์ประกอบหลักตัวแรก (eigenvalue) อธิบายความแปรปรวนส่วนใหญ่ในข้อมูล สิ่งนี้อาจเกิดขึ้นเมื่อวิธีการบีบอัดของคุณเป็นแบบเชิงเส้น อย่างไรก็ตามอาจมีการขึ้นต่อกันแบบไม่เชิงเส้นในพื้นที่คุณลักษณะของคุณ

TL / DR: PCA เป็นวิธีการเชิงเส้น ใช้ Autoencoders (ไม่ใช่เชิงเส้น PCA) สำหรับการลดขนาด หากส่วนการเรียนรู้ของเครื่องได้รับการดูแลการเรียนรู้จากนั้นเพียงแค่ตรวจสอบฟังก์ชั่นการสูญเสียของคุณในขณะที่ปรับพารามิเตอร์ (ไฮเปอร์) สำหรับเครื่องสร้างรหัสอัตโนมัติ ด้วยวิธีนี้คุณจะได้รับข้อมูลต้นฉบับที่ถูกบีบอัดที่ดียิ่งขึ้น

นี่คือตัวอย่างของ scikit ที่พวกเขาทำการค้นหากริดเพื่อค้นหาจำนวนองค์ประกอบหลักที่เหมาะสมที่จะเก็บ (พารามิเตอร์ไฮเปอร์) โดยใช้ PCA ในที่สุดพวกเขาก็ใช้การถดถอยโลจิสติกในพื้นที่มิติด้านล่าง: http://scikit-learn.org/stable/auto_examples/plot_digits_pipe.html#example-plot-digits-pipe-py

Protip: ตัวเข้ารหัสอัตโนมัติไม่มีโซลูชันแบบปิด (afaik) ดังนั้นหากบริบทของคุณคือการส่งกระแสข้อมูลหมายความว่าคุณสามารถอัปเดต autoencoder ของคุณอย่างต่อเนื่อง ด้วย pca คุณจะต้องฝึกฝนโหมดแบทช์ใหม่เป็นครั้งคราวเมื่อมีข้อมูลใหม่เข้ามา

เพื่อให้คุณสมบัติบางอย่าง "น้ำหนัก" มากขึ้นดูการทำให้เป็นปกติ (ฉันจะเริ่มจากบรรทัดฐานhttps://en.wikipedia.org/wiki/Norm_(mathematics ) คุณอาจประหลาดใจว่าการถดถอยแบบลอจิสติกที่คล้ายกันนั้นมีผลกับ perceptron อย่างไร