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

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

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

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

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

variance pca factor-rotation Feilong
источник

Нет ... varimax максимизирует сумму квадратов отклонений нагрузок, поэтому пытается сделать их как можно более неравными . Кроме того, почему вы хотите выровнять компоненты? Все дело в том, чтобы охватить как можно больше вариаций как можно меньшего числа компонентов.

Вас не устраивает простая стандартизация оценок компонентов к единичным отклонениям? Почему тогда? Какой результат вы хотите - должны ли результирующие столбцы быть некоррелированными в дополнение к равным отклонениям?

ttnphns

Из вашего описания очень похоже, что вы хотите просто «сферировать» данные (уменьшенной размерности). Это часто делается как шаг предварительной обработки в машинном обучении. Чтобы достичь этого, вы просто выполняете PCA, выбираете некоторые компоненты и стандартизируете их. Я предполагаю, что можно найти ортогональное вращение (такое как варимакс), которое вращает стандартизированные компоненты так, что они остаются некоррелированными, но объясняют точно такое же количество дисперсии; это интересный вопрос, мне нужно подумать об этом. Но я никогда не видел, чтобы это было сделано, определенно не в машинном обучении.

амеба

Кстати, какие «алгоритмы машинного обучения» вы хотите применить после PCA? Это может быть актуально.

амеба

Обратите внимание, что если вы вращаете ваши стандартизированные ПК, то расстояния не изменятся совсем! Так что это действительно не должно иметь значения для любого последующего алгоритма, основанного на расстоянии.

амеба

Ответы:

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

Пусть - центрированная матрица данных с точками данных в строках и переменными в столбцах. РСА составляет сингулярное разложение где для выполнения сокращения размерности мы держать только компоненты. Ортогональное «вращение фактора» из этих компонентов предполагает выбор ортогонального матрицы и подключить его к разложению: $\mathbf X$ $n\times d$

Икс знак равно {U S В}^{⊤} \approx U_{К} S_{К} В_{К}^{⊤},

$\mathbf X = \mathbf{USV}^\top \approx \mathbf U_k \mathbf S_k \mathbf V_k^\top,$

k

$k$

k \times k

$k \times k$

R

$\mathbf R$

Вот

Икс \approx U_{К} S_{К} В_{К}^{⊤} знак равно U_{К} {р р}^{⊤} S_{К} В_{К}^{⊤} знак равно \underset{\begin{matrix} повернутого \\ стандартизированные оценки \end{matrix}}{\underset{⏟}{\sqrt{N - 1} U_{К}^{} р}} \cdot \underset{{Поворотные нагрузки}^{⊤}}{\underset{⏟}{р^{⊤} S_{К} В_{К}^{⊤} / \sqrt{N - 1}}},

$\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} U_{k} R

$\sqrt{n-1}\mathbf U_k \mathbf R$

s_{i}^{2} / (n - 1)

$s_i^2/(n-1)$

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

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

(L р)^{⊤} L р знак равно р^{⊤} \frac{S^{2}}{N - 1} р,

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

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

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

Это перераспределит все дисперсии одинаково по последовательности 2D поворотов. Умножение всех этих матриц вращения даст общее значение $(k-1)$ $\mathbf R$ .

пример

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

(\begin{array}{cccc} 10 & 0 & 0 & 0 \\ 0 & 6 & 0 & 0 \\ 0 & 0 & 3 & 0 \\ 0 & 0 & 0 & 1 \end{array}),

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

5

$5$

$5$ $1+(10-5)=6$ .
$5$ $3+(6-5)=4$
$5$ $4+(6-1)=5$
Выполнено.

Я написал скрипт 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$

амеба
источник

Я предполагаю, что для любых двух пар компонентов (их оценки) угол поворота будет 45 градусов, чтобы выровнять их отклонения. Однако я не представляю, как выполнить всю задачу с 3+ компонентами попарно.

ttnphns

@feilong, я думаю, что выравнивание дисперсии пары компонентов за один раз является очень неоптимальным алгоритмом. Я предложил выбрать такие повороты, чтобы дисперсия одного компонента стала точно равной глобальной средней дисперсии. Тогда этот компонент «готов», и с остальным можно разобраться. Это гарантированно выровняет все дисперсии за конечное число шагов. Смотрите мой предыдущий комментарий для примера.

амеба

@amoeba Вы правы, это лучшее решение, и должно закончить с n-1 шагов.

Feilong

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

Feilong

@amoeba Специально для основных компонентов можно сэкономить больше времени, удалив детали, ища максимум и минимум. Мы можем просто повернуть 1-й и 2-й компоненты (чтобы 1-й компонент имел среднюю дисперсию), а затем 2-й и 3-й, и так далее. Нам просто нужно убедиться, что общая дисперсия каждой пары больше, чем mu.

Feilong

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

$\cos\theta$

μ^{2} знак равно {соз}^{2} θ (σ_{м a Икс}^{2}) + {грех}^{2} θ (σ_{м я N}^{2})

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

{Икс}^{*} знак равно {Икс}^{'} - ({Икс}^{'} - {Икс}^{*}) знак равно Икс соз θ - Y грех θ

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

$\mu^2$ $X^*$

μ^{2} знак равно Σ {Икс}^{* 2} знак равно Σ (Икс соз θ - Y грех θ)^{2} знак равно Σ ({Икс}^{2} {соз}^{2} θ + Y^{2} {грех}^{2} θ - 2 Икс Y соз θ грех θ) знак равно {соз}^{2} θ Σ {Икс}^{2} + {грех}^{2} θ Σ Y^{2} - \underset{= 0 (X и Y некоррелированы)}{\underset{⏟}{2 соз θ грех θ Σ Икс Y}} знак равно {соз}^{2} θ (σ_{м a Икс}^{2}) + {грех}^{2} θ (σ_{м я N}^{2})

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

ttnphns
источник

{(\begin{array}{cc} соз θ & грех θ \\ - грех θ & соз θ \end{array})}^{⊤} (\begin{array}{cc} σ_{Максимум}^{2} & 0 \\ 0 & σ_{мин}^{2} \end{array}) (\begin{array}{cc} соз θ & грех θ \\ - грех θ & соз θ \end{array}),

$\left(\begin{array}{cc}\cos \theta & \sin \theta \\ -\sin\theta & \cos \theta\end{array}\right)^\top \left(\begin{array}{cc} \sigma_\text{max}^2 & 0 \\ 0 & \sigma_\text{min}^2\end{array}\right) \left(\begin{array}{cc}\cos \theta & \sin \theta \\ -\sin\theta & \cos \theta\end{array}\right),$ и вычисление верхнего левого элемента продукта. Это, конечно, одно и то же рассуждение, просто выраженное по-разному. Спасибо!

амеба

И я думаю, что ваше геометрическое объяснение и «прямые» вычисления (без матриц) легче понять и очень полезно для разработки правильной интуиции.

амеба

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

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) ). Вы также можете быть удивлены, насколько логистическая регрессия похожа на персептрон.

сюрикен х синий
источник

Я не понимаю, как это отвечает на вопрос ОП; кажется, ваш ответ совершенно не связан с вопросом.

амеба

Поэтому мне было интересно: есть ли простой способ просто разделить его дисперсию и поделиться ею с ПК с меньшими отклонениями? ОП хочет уменьшить размерность. Я предложил альтернативу для решения его проблемы, поскольку в конечном итоге то, что хочет OP, не гарантирует повышения производительности, если производительность не измеряется. Работа в гильбертовых / нормированных пространствах не гарантирует лучших результатов. Измерение производительности приводит к лучшим результатам.

сюрикен х синий