Вращайте компоненты PCA, чтобы выровнять дисперсию в каждом компоненте

Я пытаюсь уменьшить размерность и шум набора данных, выполняя PCA для набора данных и выбрасывая последние несколько ПК. После этого я хочу использовать некоторые алгоритмы машинного обучения на оставшихся ПК, и поэтому я хочу нормализовать данные путем выравнивания дисперсии ПК, чтобы алгоритмы работали лучше.

Один простой способ - просто нормализовать дисперсию для значений единиц. Однако первый компьютер содержит больше отклонений от исходного набора данных, чем следующие, и я все еще хочу придать ему больше «веса». Поэтому мне было интересно: есть ли простой способ просто разделить его дисперсию и поделиться ею с ПК с меньшими отклонениями?

Другой способ - отобразить ПК обратно в исходное пространство объектов, но в этом случае размерность также увеличится до исходного значения.

Я предполагаю, что лучше сохранять результирующие столбцы ортогональными, но в этом нет необходимости.

Мне не совсем ясно, что вы спрашиваете, что вам действительно нужно: обычным этапом предварительной обработки в машинном обучении является уменьшение размерности + отбеливание, что означает выполнение PCA и стандартизацию компонентов, и ничего больше. Но я все же остановлюсь на вашем вопросе в том виде, как он сформулирован, потому что он более интересен.

---

Пусть - центрированная матрица данных n × d с точками данных в строках и переменными в столбцах. РСА составляет сингулярное разложение Х = U S V ⊤ ≈ U K S K V ⊤ K , где для выполнения сокращения размерности мы держать только K компоненты. Ортогональное «вращение фактора» из этих компонентов предполагает выбор ортогонального K × K матрицы R и подключить его к разложению: X ≈ U K S к $\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$Вот $$\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}.$$ - повернутые стандартизированные компоненты, а второй член представляет повернутые нагрузки, транспонированные. Дисперсия каждого компонента после вращения задается суммой квадратов соответствующего вектора нагрузки; перед вращением это простоs 2 i /(n-1). После вращения это что-то еще.$\sqrt{n-1}\mathbf U_k \mathbf R$$s_i^2/(n-1)$

Теперь мы готовы сформулировать задачу в математических терминах: с учетом неповрежденных нагрузок , найдите матрицу вращенияRтак, чтобы вращаемые нагрузки,LR, имели равную сумму квадратов в каждом столбце.$\mathbf L = \mathbf V_k \mathbf S_k / \sqrt{n-1}$$\mathbf R$$\mathbf L \mathbf R$

Давайте решать это. Суммы столбцов квадратов после вращения равны диагональным элементам Это имеет смысл: вращение просто перераспределяет дисперсии компонентов, которые первоначально определяются как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$

Я не думаю, что есть закрытое решение этой проблемы, и на самом деле есть много разных решений. Но решение может быть легко построено последовательным способом:

1. Возьмите первый компонент и компонент. Первый из них имеет дисперсию сг макс > М , а последний имеет дисперсию сг мин < μ .$k$$\sigma_\text{max}>\mu$$\sigma_\text{min}<\mu$
2. Вращайте только эти два, так что дисперсия первого становится равной . Вращение матрицы в 2D зависит только от одного параметра θ, и легко записать уравнение и вычислить необходимое θ . Действительно, R 2D = ( Cos & thetas грех & thetas ; - грех & thetas ; соз & thetas ; ) и после преобразования первого ПК будет получить дисперсию сов 2 & thetas ; ⋅ сг макс + грех 2 & thetas ; ⋅ сг мин = соз 2 & thetas ; ⋅ $\mu$$\theta$$\theta$ $$\mathbf R_\text{2D} = \left(\begin{array}{cc}\cos \theta & \sin \theta \\ -\sin\theta & \cos \theta\end{array}\right)$$ из которых мы сразу получаем соз 2 & thetas ; = ц - сг $$\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.

Это перераспределит все дисперсии одинаково по последовательности 2D поворотов. Умножение всех этих матриц вращения даст общее значение $(k-1)$$\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. $5$$1+(10-5)=6$ .

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

3. $5$$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$

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

но не продемонстрировал, откуда это уравнение; вероятно, думая, что это очевидно без объяснения причин. Очевидно это или нет, я полагаю, что это стоит объяснить - в некотором роде. Мой ответ представляет один из способов.

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

Если я правильно интерпретирую вещи, вы имеете в виду, что первый основной компонент (собственное значение) объясняет большую часть различий в данных. Это может произойти, когда ваш метод сжатия является линейным. Однако в вашем пространстве пространственных объектов могут быть нелинейные зависимости.

TL / DR: PCA - это линейный метод. Используйте автоэнкодеры (нелинейные pca) для уменьшения размерности. Если часть машинного обучения - контролируемое обучение, просто следите за своей функцией потерь, настраивая (гипер) параметры для автоэнкодера. Таким образом, вы получите гораздо более сжатую версию исходных данных.

Вот пример scikit, где они выполняют поиск по сетке, чтобы найти оптимальное количество главных компонентов, которые нужно сохранить (гиперпараметр), используя PCA. Наконец, они применяют логистическую регрессию к пространству нижних измерений: http://scikit-learn.org/stable/auto_examples/plot_digits_pipe.html#example-plot-digits-pipe-py

Подсказка: автоэнкодеры не имеют решения для закрытой формы (afaik), поэтому, если ваш контекст представляет собой потоковую передачу данных, это означает, что вы можете постоянно обновлять свой автоэнкодер (сжатое представление) и, таким образом, компенсировать такие вещи, как смещение концепции. С помощью pca вы должны периодически переучивать пакетный режим по мере поступления новых данных.

Что касается придания некоторым функциям большего «веса», смотрите регуляризацию (я бы начал с норм https://en.wikipedia.org/wiki/Norm_(matmatics) ). Вы также можете быть удивлены, насколько логистическая регрессия похожа на персептрон.