二、关于 SOM

        芬兰教授Teuvo Kohonen在1980年代提出的自组织地图或SOM提供了一种在保留数据拓扑的同时对数据集进行低维和离散化表示的方法，称为“地图”。

        目标是学习一个以类似方式响应类似输入模式的地图。它被学习为一个权重数组，它被解释为一个神经元数组，其中每个神经元本身都是一个与输入数据点具有相同维度的向量，如下所示。神经元直接受到输入数据的影响。

        权重数组中神经元之间的距离用于生成表征数据分布的映射。

        SOM 具有轻松可视化特征行为的优势。由于可以从学习的表示中访问各个特征，因此表示每个特征的数据行为。

        让我们分解一下：

        “自组织”

        SOM 是一种无监督的人工神经网络。它不是使用误差最小化技术，而是使用竞争性学习。特征向量使用数据点和学习表示之间的基于距离的指标映射到低维表示，不需要任何其他计算，使其“自组织”。

“地图”

学习到的结果权重由U矩阵（统一距离矩阵，下面详细解释）表示，这是一个表示神经元之间距离的“映射”。学习SOM背后的想法是，形成的映射以类似的方式响应类似的输入，在生成的映射的某些区域中将类似的输入组合在一起。

三、在 Python 中的实现

        Eklavya 连贯地解释了该算法，提供了带有变量适当表示的分步解释，我们也将用于我们的 Python 实现。

        目标是学习一个权重数组，在我们的例子中是一个 3D 数组，但被解释为神经元大小为 x 的 2D 数组，其中每个神经元都是长度的 1D 向量。我们正在学习数据集的 2D 表示。 然后用于生成 U 矩阵 — 整个数据集的单个 2D 地图。Wlengthwidthn_featuresW

图1 - 权重数组“W”

        每个输入向量用于更新 。最接近数据点的神经元是最佳匹配单元（BMU）。其余神经元与BMU的距离用于更新邻域函数，该函数是更新的基础。中较大的值表示相似输入向量的聚类。邻域函数的学习率和半径随时间衰减，因为邻域变小，即相似的输入被分组得更紧密。WWWW

        首先，导入所有必要的库。

from sklearn.preprocessing import MinMaxScaler, StandardScaler
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
import random
import time
from itertools import product

四、第一部分：从数据集导入到权重获取

        对于数据，我们使用用于预测胎儿健康的数据集，该数据集将胎儿的健康分类为 、 或使用 CTG 数据。它有 22 个功能，但我们只关注前 10 个功能：NormalSuspectPathological

filein = "fetal_health.csv"
data = np.loadtxt(open(filein, "rb"), delimiter = ",", skiprows = 1)
features = ['baseline value', 'accelerations', 'fetal_movement', 'uterine_contractions', 'light_decelerations', 'severe_decelerations', 'prolongued_decelerations', 'abnormal_short_term_variability', 'mean_value_of_short_term_variability', 'percentage_of_time_with_abnormal_long_term_variability']
X_data = np.array(data)[:,0:len(features)]print("Number of datapoints: ", X_data.shape[0])
print("Number of features: ", X_data.shape[1])

        而且，由于它使用基于距离的指标，我们将继续缩放输入：

scaler = MinMaxScaler()
X_data = scaler.fit_transform(X_data) # normalizing, scaling

        现在，深入探讨算法实现的细节。首先，我们看一下超参数：

n_features = X_data.shape[1]
max_iter = 1000                                   # max. no. of iterations
length = 50                                       # length of W
width = 50                                        # width of W
W = np.random.rand([length, width, n_features])   # initial weights
aplha0 = 0.9                                      # initial learning rate
beta = [[]]                                       # neighbourhood function
sigma0 = max(length, width)                       # initial radius of beta
TC = max_iter/np.log(sigma0)                      # time constant

• length， ， — 权重矩阵的维度，其中 和 指定 feaure 地图的大小，值越高，结果越精细。使用随机值初始化。widthn_feauturesWlengthwidthW
• max_iter— 我们想要运行算法的最大迭代次数。
• TC— 用于学习率和邻域半径衰减的时间常数。
• alpha0— 动态学习率的初始值。学习率衰减为时间步长或迭代次数t的指数函数：alphat

def aplhaUpdate(t):return aplha0*np.exp(-t/TC)

• sigma0— 邻域函数的动态（收缩）半径的初始值。我们从一个半径开始，该半径覆盖了神经元的整个 2D 映射。它的更新方式与 相同。Walpha

def sigmaUpdate(t):return sigma0*np.exp(-t/TC)

• beta一个 2D 向量，用于存储 中每个节点的邻域函数的值。BMU
• BMU— est atching nit 是最接近输入数据点的节点，即与它的距离最短，在我们的例子中，欧几里得距离，如下所示。BMUx_n

def winningNode(x_n, W): # Find the winning node and distance to itdist = np.linalg.norm(x_n - W, ord =2 , axis = 2)d = np.min(dist)BMU = np.argwhere(dist == np.min(dist))return d, BMU

• 要更新，我们首先需要找到权重向量中每个节点与 . 是表示每个长向量到每个其他向量的欧几里得距离的向量，其中每个向量由其 x 和 y 坐标表示。betaBMUhardDistn_featureWWcoords

hardDist = np.zeros([length, width, length, width])
for i,j,k,l in product(range(length),range(width),range(length),range(width)):hardDist[i,j,k,l]= ((i-k)**2 + (j-l)**2)**0.5

• gridDistances用于访问表示距离或每个向量在位置 的 2D 数组。coords

def gridDistances(coords):return hardDist[coords[0][0],coords[0][1],:,:]

• 然后我们可以更新 .对于每个输入向量，计算为最接近 的点提供最小值。betabetaBMU

def betaUpdate(coords, sigma): # neighbourhood functionreturn np.exp(-gridDistances(coords)**2/(2*sigma**2))

• 下图显示了一个权重数组，在第二张图中可以想象为矢量神经元的 2D 数组。以红色突出显示的矢量是 BMU。蓝色表面显示了每个神经元的值，在BMU处最高。的值表示二维正态分布。Wbetabeta

图 2 — W，BMU 以红色突出显示（左和右），为 sigma=1.5 绘制的 beta 值，显示 BMU 处的 beta 值最高。

• 最后，我们可以更新 .我们看到有三个因素影响了更新：（1），它在数据集的一次迭代中是恒定的;（2）、每个向量与输入向量的差值;和（3） .将因子添加到 ，因此对于靠近输入的向量，的值更大，从而导致 中的向量值更大。WWalphaf=x_n-WWbetaalpha*beta*fWWbetaW

def weightUpdate(W, aplha, beta, x_t):f= (x_t-W)beta = np.reshape(beta,[beta.shape[0],beta.shape[1],1])return W+aplha*beta*f

        现在，我们已经讨论了初步内容，我们可以将它们放在一起：

errors=np.zeros([max_iter])for t in range(max_iter): t1 = time.time()alpha = aplhaUpdate(t)sigma = sigmaUpdate(t)np.random.shuffle(X_data)n_sample = len(X_data) # iterating over whole datasetQE = 0for n in range(n_sample):d, BMU = winningNode(X_data[n,:], W)QE = QE + dbeta = betaUpdate(BMU, sigma)W = weightUpdate(W, alpha, beta, X_data[n,:])W /= np.linalg.norm(W, axis=2).reshape((length, width, 1))QE /= n_sampleerrors[t]=QEt1 = time.time() - t1print("Iteration: ", "{:05d}".format(t), " | Quantization Error: ", "{:10f}".format(QE),  " | Time: ", "{:10f}".format(t1))

让我们一步一步地看一下。

• 对于每次迭代，并略微衰减以适应 中的逐渐变化。alphasigmaW
• 对于数据集中的每个输入向量，我们找到 BMU 和 BMU 与输入向量的距离 .d
• beta根据BMU进行更新，然后用于更新.W
• W被归一化，以便在不同的值下保持可比性。Wt
• 为了监控学习过程，我们使用量化误差，这是每个数据点到其BMU的距离的平均值。如果更新正确，它应该在迭代中减少。QEW

当我们在数据集上运行它时，我们得到以下输出：

我们可以通过沿其代表特征的最后一个维度切片来绘制各个特征图。W

图3 - 特征图

        这样就完成了学习获取单个特征图的第一步。W