第二部分是简单地计算神经元之间的距离以获得U矩阵（Unified-distance矩阵），它可以是六边形或矩形。在下图中，我们看到了查看 中神经元 2D 数组的两种方式。W

图 5 — W、六边形（左）和矩形（右）的不同解释

        U矩阵表示神经元之间的距离。下图显示了六边形和矩形表示的 U 矩阵。在两张图像中，黄色细胞表示相邻神经元之间的距离，例如，{1，2}是上图中神经元1和2之间的距离。橙色单元格表示从神经元数到周围神经元的距离的平均值，即 {1}=mean（{1，2}， {1，4}） 或 {5}=mean（{2，5}， {4，5}， {5，6}， {5，7}， {5，8}， {5，9}） 对于六边形 U 矩阵，{5}=mean（{2，5}， {4，5}， {5，6}， {5，8}） 对于矩形矩阵。

图 6 — U 矩阵，六边形（左）和矩形（右）

        在矩形 U 矩阵中，还有一种其他类型的单元格，以蓝色突出显示。我们不能将其视为蓝色单元格角上的橙色单元格之间的距离，例如平均值（{1}，{5}）或平均值（{2}，{4}），因为这些值对蓝色单元格都有效，但不相等，这将是矛盾的。因此，我们将该值作为其周围黄色单元格的平均值，从而允许最终 U 矩阵中的单元格之间更平滑地过渡。有关进一步说明，请参阅此文章。下面给出了两种类型的 U 矩阵的计算。

        对于黄色单元格，我们计算相邻神经元之间的距离，橙色和蓝色单元格计算为它们上方、下方和两侧单元格的平均值。

# CALCULATION OF RECTANGULAR U-MATRIX FROM W
def make_u_rect(W):

    U = np.zeros([W.shape[0]*2-1, W.shape[1]*2-1], dtype=np.float64)

    # YELLOW CELLS
    for i in range(W.shape[0]): # across columns
        k=1
        for j in range(W.shape[1]-1):
            U[2*i, k]= np.linalg.norm(W[i,j]-W[i,j+1], ord=2)
            k += 2

    for j in range(W.shape[1]): # down rows
        k=1
        for i in range(W.shape[0]-1):
            U[k,2*j] = np.linalg.norm(W[i,j]-W[i+1,j], ord=2)
            k+=2

    # ORANGE AND BLUE CELLS - average of cells top, bottom, left, right.
    for (i,j) in product(range(U.shape[0]), range(U.shape[1])):
        if U[i,j] !=0: continue
        all_vals = np.concatenate((
               U[(i-1 if i>0 else i): (i+2 if i<=U.shape[0]-1 else i), j],
               U[i, (j-1 if j>0 else j): (j+2 if j<=U.shape[1]-1 else j)]))
        U[i,j] = all_vals[all_vals!=0].mean()
    
    # Normalizing in [0-1] range for better visualization.
    scaler = MinMaxScaler()
    return scaler.fit_transform(U)

        对于六边形矩阵，我们使用神经元本身的值作为位置{1}、{2}、...以简化 中 {1，2}、{2，3} 等的计算。{1}, {2}, ...然后替换为其周围值的平均值。U

# CALCULATION OF HEXAGONAL U-MATRIX FROM W
def make_u_hex(W): 
    
    # Creating arrays with extra rows to accommodate hexagonal shape.
    U_temp =  np.zeros([4*W.shape[0]-1, 2*W.shape[1]-1, W.shape[2]])
    U = np.zeros([4*W.shape[0]-1, 2*W.shape[1]-1])
    """
    The U matrix is mapped to a numpy array as shown below.
    U_temp holds neuron at postion 1 in place of {1} for easy computation
    of {1,2}, {2,3} etc. in U. {1}, {2}, {3}, ... are computed later.
    [
      [    (1),        0,       0,       0,    (3)],
      [      0,    (1,2),       0,   (2,3),      0],
      [   (1,4),       0,     (2),       0,  (3,6)],
      [      0,    (2,4),       0 ,  (2,6),      0],
      [    (4),        0,    (2,5),      0,    (6)],
      [      0,    (4,5),        0,  (5,6),      0],
      [   (4,7),       0,      (5),      0,  (6,9)],
      [      0,    (2,4),        0,  (5,9),      0],
      [    (7),        0,    (5,8),      0,    (9)],
      [      0,    (7,8),        0,  (8,9),      0],
      [      0,        0,      (8),      0,      0]
    ]
    """

    # Creating a temporary array placing neuron vectors in 
    # place of orange cells.
    k=0
    indices = []
    for i in range(W.shape[0]):
        l=0
        for j in range(W.shape[1]):
            U_temp[k+2 if l%4!=0 else k,l,:] = W[i,j,:]
            indices.append((k+2 if l%4!=0 else k,l))
            l+=2
        k += 4
    
    # Finding distances for YELLOW cells.
    for (i,j),(k,l) in product(indices, indices):
        if abs(i-k)==2 and abs(j-l)==2:      # Along diagonals
            U[int((i+k)/2), int((j+l)/2)] = 
                np.linalg.norm(U_temp[i,j,:]-U_temp[k,l,:], ord=2)
        
        if abs(i-k)==4 and abs(j-l)==0:       # In vertical direction
            U[int((i+k)/2), int((j+l)/2)] = 
                np.linalg.norm(U_temp[i,j,:]-U_temp[k,l,:], ord=2)
    
    # Calculating ORANGE cells as mean of immediate surrounding cells.
    for (i,j) in indices:
        all_vals = 
          U[(i-2 if i-1>0 else i): (i+3 if i+2<U.shape[0]-1 else i), 
            (j-1 if j>0 else j): (j+2 if j<=U.shape[1]-1 else j)]
        U[i,j] = np.average(all_vals[all_vals!=0])
    
    # To remove extra rows introduced in above function.
    new_U = collapse_hex_u(U)

    # Normalizing in [0-1] range for better visualization.
    scaler = MinMaxScaler()
    return scaler.fit_transform(new_U)


def collapse_hex_u(U):

    new_U = np.zeros([int((U.shape[0]+1)/2), U.shape[1]])
    # Moving up values in every alternate column
    for j in range(1, U.shape[1], 2):
            for i in range(U.shape[0]-1):
                U[i,j]=U[i+1,j]

    # Removing extra rows
    for i in range(new_U.shape[0]): new_U[i,:] = U[2*i,:]

    return new_U

        要绘制六边形网格，我们需要自己在图上绘制六边形。对于折叠的六边形，我们可以绘制 U 矩阵，方法是为每个点绘制一个六边形，每两列有一个轻微的 y 偏移量，以制作一个网格，如图 6 所示。U

def draw_hex_grid(ax, U):

    def make_hex(ax, x, y, colour):
        if x%2==1: y=y+0.5
        xs = np.array([x-0.333,x+0.333,x+0.667,x+0.333,x-0.333,x-0.667])
        ys = np.array([  y+0.5,  y+0.5,      y,  y-0.5,  y-0.5,      y])
        ax.fill(xs, ys, facecolor = colour)
    
    ax.invert_yaxis()
    cmap = matplotlib.cm.get_cmap('jet')

    for (i,j) in product(range(U.shape[0]), range(U.shape[1])):
        if U[i,j]==0: rgba='white'
        else: rgba = cmap(U[i,j])
        make_hex(ax, i, j, rgba)
        
    ax.set_title("U-Matrix (Hexagonal)")

图 3 所示的两种类型的 U 矩阵结果为：W

图 7 — U 矩阵

        在学习过程中拍摄如图 3 所示的快照，我们可以观察每个特征图和 U 矩阵的学习情况。上面显示的颜色图显示，红色表示最大值，表示该区域中聚集的更多输入数据点，而模糊区域表示输入数据点稀疏出现的空间。W

        随着迭代的进行，学习速度变慢了。在开始的迭代中，特征图变化很大，而在以后的迭代中，它们变得有些稳定。矩阵也出现了同样的趋势，社区的规模在缩小。这也反映在 中，其下降速率随时间而降低。哈尼亚·安尤姆

 显示“W”和“U”学习的.gif图像（在新选项卡中打开以再次播放）