Математика для нейронного обучения

Реализация (используя scikit-learn):

import numpy as np
from sklearn.manifold import MDS

# X - исходные данные или матрица попарных расстояний
# n_components_mds - целевая размерность
# X_data = # ... ваши данные
# n_components_mds = 2

# metric=True означает, что MDS пытается сохранить исходные расстояния (метрическое MDS)
# metric=False (по умолчанию) использует SMACOF (неметрическое MDS)
# mds = MDS(n_components=n_components_mds, metric=True, random_state=0, normalized_stress='auto')
# X_mds = mds.fit_transform(X_data)

# Значение стресса сохраняется в mds.stress_
# print(f"MDS Stress: {mds.stress_}")

8.11. Многомерное шкалирование (MDS - Multidimensional Scaling)

Объяснение: MDS вкладывает данные в пространство меньшей размерности, пытаясь сохранить попарные расстояния (или их ранги в неметрическом MDS) настолько точно, насколько это возможно.

Реализация (используя scikit-learn): См. реализацию в 8.10.

8.12. NMF (Неотрицательная матричная факторизация / Non-Negative Matrix Factorization)

Объяснение: NMF факторизует неотрицательную матрицу на две неотрицательные матрицы меньшего ранга. Часто используется в тематическом моделировании (topic modeling) и обработке изображений (выделение частей).

Реализация (используя scikit-learn):

import numpy as np
from sklearn.decomposition import NMF

# X - исходная неотрицательная матрица (n_samples, n_features)
# k - количество компонент (ранг)
# X_data_nonneg = np.abs(np.random.rand(50, 30)) # Пример неотрицательных данных
# k_nmf = 5

# nmf_model = NMF(n_components=k_nmf, init='random', random_state=0, max_iter=300)
# W = nmf_model.fit_transform(X_data_nonneg) # Матрица W (компоненты)
# H = nmf_model.components_              # Матрица H (коэффициенты)

# print(f"Shape of W: {W.shape}") # (n_samples, k) - Если fit_transform
# В стандартной нотации W - это (n_features, k), H - (k, n_samples)
# sklearn NMF возвращает W как (n_samples, k), а H как (k, n_features)
# print(f"Shape of H (components_): {H.shape}") # (k, n_features)

# Реконструкция: X_approx = W @ H

8.13. Цель ICA (Анализ независимых компонент / Independent Component Analysis)

Объяснение: ICA разделяет смешанные сигналы на статистически независимые компоненты путем максимизации их не-Гауссовости (или минимизации взаимной информации).

Реализация (используя scikit-learn):

import numpy as np
from sklearn.decomposition import FastICA

# X - матрица наблюдаемых сигналов (n_samples, n_features)
# k - количество компонент для извлечения
# X_mixed = # ... ваши смешанные сигналы
# k_ica = # ... количество источников

# ica = FastICA(n_components=k_ica, random_state=0)
# S_estimated = ica.fit_transform(X_mixed) # Оцененные независимые компоненты (источники)
# W_mixing = ica.mixing_ # Оцененная матрица смешивания A (X = S @ A.T)
# W_unmixing = ica.components_ # Оцененная разделяющая матрица W (S = X @ W.T)

# print(f"Shape of estimated sources: {S_estimated.shape}")

8.14. Модель факторного анализа (Factor Analysis)

Объяснение: Факторный анализ моделирует наблюдаемые переменные как линейные комбинации скрытых (латентных) факторов плюс шум (уникальные факторы).

Реализация (используя scikit-learn):

import numpy as np
from sklearn.decomposition import FactorAnalysis

# X - исходные данные (n_samples, n_features)
# k - количество латентных факторов
# X_data = # ... ваши данные
# k_factors = 3

# fa = FactorAnalysis(n_components=k_factors, random_state=0)
# X_factors = fa.fit_transform(X_data) # Значения латентных факторов для данных

# print(f"Shape of factor scores: {X_factors.shape}") # (n_samples, k_factors)
# print("Factor Loadings (Lambda):\n", fa.components_.T) # (n_features, k_factors)
# print("Noise Variance (Psi diagonal):\n", fa.noise_variance_) # (n_features,)

8.15. Преобразование Kernel PCA (Ядерный PCA)

Объяснение: Ядерный PCA применяет PCA в высокоразмерном пространстве признаков, неявно определенном функцией ядра \(k\), позволяя находить нелинейные главные компоненты.

Реализация (используя scikit-learn):

import numpy as np
from sklearn.decomposition import KernelPCA

# X - исходные данные (n_samples, n_features)
# k - количество компонент
# kernel_type - тип ядра ('rbf', 'poly', 'sigmoid', 'linear', etc.)
# X_data = # ... ваши нелинейно разделимые данные
# k_kpca = 2
# kernel_type = 'rbf' # Радиальная базисная функция (Гауссово ядро)

# kpca = KernelPCA(n_components=k_kpca, kernel=kernel_type, gamma=None, random_state=0) # gamma - параметр для RBF
# X_kpca = kpca.fit_transform(X_data)

# print(f"Shape after Kernel PCA: {X_kpca.shape}") # (n_samples, k_kpca)

8.16. LDA (Критерий Фишера / Fisher's Criterion)

Объяснение: Линейный дискриминантный анализ (LDA) находит проекцию, которая максимизирует разделение между классами путем оптимизации отношения межклассовой дисперсии к внутриклассовой дисперсии.

Реализация (используя scikit-learn):

import numpy as np
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

# X - исходные данные (n_samples, n_features)
# y - метки классов (n_samples,)
# k - количество компонент (<= n_classes - 1)
# X_data = # ... ваши данные для классификации
# y_labels = # ... метки классов
# k_lda = # min(n_features, n_classes - 1)

# lda = LinearDiscriminantAnalysis(n_components=k_lda)
# X_lda = lda.fit_transform(X_data, y_labels) # Используем и X, и y

# print(f"Shape after LDA: {X_lda.shape}") # (n_samples, k_lda)

8.17. Робастный PCA (RPCA)

Объяснение: RPCA разлагает матрицу на низкоранговую компоненту (основная структура) и разреженную компоненту (выбросы, ошибки), делая PCA робастным к аномалиям.

Реализация (используя библиотеку r_pca, если установлена):

# Требуется установка: pip install rpca
# import numpy as np
# from r_pca import R_pca

# X - исходная матрица (может содержать выбросы)
# X_data_corrupted = # ... ваши данные с выбросами

# Инициализируем модель RPCA
# rpca = R_pca(X_data_corrupted)
# L, S = rpca.fit(max_iter=1000, iter_print=100) # Выполняем разложение

# print("Shape of Low-Rank matrix L:", L.shape)
# print("Shape of Sparse matrix S:", S.shape)
# print("Percentage of non-zero elements in S:", np.sum(np.abs(S)>1e-6) / S.size * 100)

8.18. Hessian LLE (Локально-линейное вложение с Гессианом)

Объяснение: Hessian LLE сохраняет локальные геометрические структуры (включая информацию о кривизне), оптимизируя низкоразмерное вложение.

Реализация (используя scikit-learn):

import numpy as np
from sklearn.manifold import LocallyLinearEmbedding

# X - исходные данные
# k_neighbors - количество соседей
# n_components_hlle - целевая размерность
# X_data = # ... ваши данные на многообразии
# k_neighbors = 10
# n_components_hlle = 2

# hessian_lle = LocallyLinearEmbedding(n_neighbors=k_neighbors,
#                                      n_components=n_components_hlle,
#                                      method='hessian', # Используем гессиановский собственный метод
#                                      random_state=0)
# X_hlle = hessian_lle.fit_transform(X_data)

# print(f"Shape after Hessian LLE: {X_hlle.shape}")

8.19. Цель Laplacian Eigenmaps (Лапласовы собственные карты)

Объяснение: Laplacian Eigenmaps вкладывает данные, сохраняя локальную информацию о соседстве на основе структуры графа (близкие точки в исходном пространстве должны оставаться близкими во вложенном).

Реализация (используя scikit-learn):

import numpy as np
from sklearn.manifold import SpectralEmbedding

# X - исходные данные
# k - количество компонент (целевая размерность)
# n_neighbors_le - количество соседей для построения графа
# X_data = # ... ваши данные
# k_le = 2
# n_neighbors_le = 10

# affinity='nearest_neighbors' или 'rbf'
# laplacian = SpectralEmbedding(n_components=k_le,
#                               affinity='nearest_neighbors',
#                               n_neighbors=n_neighbors_le,
#                               random_state=0)
# X_laplacian = laplacian.fit_transform(X_data)

# print(f"Shape after Laplacian Eigenmaps: {X_laplacian.shape}")

8.20. Реконструкция автоэнкодером

Объяснение: Автоэнкодеры минимизируют ошибку реконструкции путем сжатия данных в латентное представление (кодирование) и последующего восстановления (декодирования).

Реализация (концептуально, с Keras/TensorFlow):

# import tensorflow as tf
# from tensorflow.keras.layers import Input, Dense
# from tensorflow.keras.models import Model

# X_data = # ... ваши данные
# input_dim = X_data.shape[1]
# encoding_dim = 32 # Размер латентного пространства

# # --- Построение модели ---
# input_layer = Input(shape=(input_dim,))
# # Энкодер
# encoded = Dense(128, activation='relu')(input_layer)
# encoded = Dense(64, activation='relu')(encoded)
# encoded = Dense(encoding_dim, activation='relu')(encoded) # Латентное представление
# # Декодер
# decoded = Dense(64, activation='relu')(encoded)
# decoded = Dense(128, activation='relu')(decoded)
# decoded = Dense(input_dim, activation='sigmoid')(decoded) # Выходной слой (сигмоид для [0,1] или линейный)

# # Модели
# autoencoder = Model(input_layer, decoded) # Полный автоэнкодер
# encoder = Model(input_layer, encoded) # Отдельно энкодер

# # --- Компиляция и обучение ---
# autoencoder.compile(optimizer='adam', loss='mse') # Обучаем минимизировать MSE
# autoencoder.fit(X_data, X_data, epochs=50, batch_size=32, validation_split=0.2)

# --- Реконструкция ---
# X_reconstructed = autoencoder.predict(X_data)

8.21. Латентное представление автоэнкодера

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

Реализация (концептуально, с Keras/TensorFlow):

# После обучения автоэнкодера (см. 8.20)

# X_data = # ... ваши данные
# latent_representation = encoder.predict(X_data) # Получаем сжатое представление

# print(f"Shape of latent representation Z: {latent_representation.shape}") # (n_samples, encoding_dim)

8.22. Цель разреженного PCA (Sparse PCA)

Объяснение: Разреженный PCA вводит разреженность (много нулей) в главные компоненты (векторы нагрузок \(\mathbf{w}\)), чтобы улучшить их интерпретируемость.

Реализация (используя scikit-learn):

import numpy as np
from sklearn.decomposition import SparsePCA

# X - исходные данные (обычно центрированные)
# k - количество компонент
# alpha - параметр L1 регуляризации (контролирует разреженность)
# X_centered = X - np.mean(X, axis=0)
# k_spca = 5
# alpha_spca = 1.0 # Подбирается экспериментально

# spca = SparsePCA(n_components=k_spca, alpha=alpha_spca, random_state=0)
# Z = spca.fit_transform(X_centered) # Данные в разреженном PCA пространстве

# print("Shape after Sparse PCA:", Z.shape)
# print("Sparse PCA components (loadings):\n", spca.components_) # Строки - компоненты
# print("Number of non-zero elements in first component:", np.sum(np.abs(spca.components_[0]) > 1e-6))

8.23. Цель t-SNE (t-distributed Stochastic Neighbor Embedding)

Объяснение: t-SNE минимизирует дивергенцию Кулльбака-Лейблера между распределениями сходства точек в высокоразмерном и низкоразмерном пространствах. Особенно хорош для визуализации.

Реализация (используя scikit-learn):

import numpy as np
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt

# X - исходные данные
# k - целевая размерность (обычно 2 или 3 для визуализации)
# perplexity - параметр, связанный с числом ближайших соседей (обычно 5-50)
# X_data = # ... ваши данные
# k_tsne = 2
# perplexity_tsne = 30.0

# tsne = TSNE(n_components=k_tsne, perplexity=perplexity_tsne, random_state=0, n_iter=300)
# X_tsne = tsne.fit_transform(X_data)

# print(f"Shape after t-SNE: {X_tsne.shape}")
# Значение KL дивергенции после оптимизации: tsne.kl_divergence_

# Визуализация (если k_tsne=2)
# plt.figure(figsize=(6, 6))
# plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y_labels) # Раскрасить по меткам, если есть
# plt.title('t-SNE Visualization')
# plt.xlabel('t-SNE Component 1')
# plt.ylabel('t-SNE Component 2')
# plt.show()

8.24. Градиент t-SNE

Объяснение: Градиент целевой функции t-SNE используется для обновления положений точек во вложенном (низкоразмерном) пространстве, чтобы привести распределение \(Q\) в соответствие с \(P\).

Реализация: Градиент вычисляется внутри реализации `sklearn.manifold.TSNE` или других библиотек, реализующих t-SNE.

8.25. UMAP (Uniform Manifold Approximation and Projection)

Объяснение: UMAP сохраняет как локальные, так и глобальные структуры данных путем оптимизации графового представления данных в исходном и низкоразмерном пространствах, часто быстрее t-SNE и лучше сохраняет глобальную структуру.

Реализация (используя библиотеку umap-learn):

# Требуется установка: pip install umap-learn
# import numpy as np
# import umap
# import matplotlib.pyplot as plt

# X - исходные данные
# k - целевая размерность
# n_neighbors_umap - количество соседей
# min_dist_umap - минимальное расстояние между точками во вложенном пространстве
# X_data = # ... ваши данные
# k_umap = 2
# n_neighbors_umap = 15
# min_dist_umap = 0.1

# reducer = umap.UMAP(n_components=k_umap,
#                    n_neighbors=n_neighbors_umap,
#                    min_dist=min_dist_umap,
#                    random_state=0)
# X_umap = reducer.fit_transform(X_data)

# print(f"Shape after UMAP: {X_umap.shape}")

# Визуализация (если k_umap=2)
# plt.figure(figsize=(6, 6))
# plt.scatter(X_umap[:, 0], X_umap[:, 1], c=y_labels) # Раскрасить по меткам, если есть
# plt.title('UMAP Visualization')
# plt.xlabel('UMAP Component 1')
# plt.ylabel('UMAP Component 2')
# plt.show()

Другие статьи по этой теме:

• 100 Страниц о машинном обучении