神经网络|(十三)|SOM神经网络

【1】引言

前序已经对神经网络有了基础认识，今天先学习SOM神经网络。

前序学习文章链接包括且不限于：

神经网络|(十一)|神经元和神经网络-CSDN博客

神经网络|(十二)|常见激活函数-CSDN博客

【2】SOM神经网络

SOM神经网络是一种结构比较简单、但是理解起来稍微复杂的神经网络。

结构简单是因为它只有两层，第一层是输入层，第二层是输出层。

和之前学习文章中提及到的一样：输入层的每一个元素都会直接作用到输出层的每一个元素。

【3】代码测试

这里逐步给出代码，通过代码的学习，大家对SOM算法的理解会相对深入。

【3.1】准备工作

首先引入必要的模块：

import numpy as np  #引入numpy模块
import matplotlib.pyplot as plt  #引入matplotlib模块

然后定义数据集：

# 生成 100行2列的位于[0,1)区间内，符合均匀分布的随机数
data = np.random.rand(100, 2)

之后为SOM算法准备一些初始数据：

# SOM 参数设置
# 输出层网格的大小（行数和列数）
# grid_size是存储数据的元组，不是矩阵
grid_size = (10, 10)
# 输入数据的维度
# input_dim取到的是data数组的列数
input_dim = data.shape[1]
# 最大迭代次数
max_iterations = 100
# 初始学习率
initial_learning_rate = 0.5
# 初始邻域半径
# 内置函数max()在元组grid_size中遍历每个元素，然后取出最大值
initial_radius = max(grid_size) / 2
# 时间常数，用于控制学习率和邻域半径的衰减速度
# 时间常数有多种定义方式，这是其中的一种
time_constant = max_iterations / np.log(initial_radius)

# 初始化 SOM 权重
# 权重矩阵的形状为 (行数, 列数, 输入维度)
# weights是一个grid_size[0]层，每一层的行列为(grid_size[1], input_dim)形式的矩阵
weights = np.random.rand(grid_size[0], grid_size[1], input_dim)

【3.2】子函数

【3.2.1】decay_function()函数

# 定义学习率和邻域半径的衰减函数
def decay_function(initial_value, iteration, time_constant):
    return initial_value * np.exp(-iteration / time_constant)

【3.2.2】calculate_distances()函数

# 计算输入向量与所有神经元权重之间的欧氏距离
# 使用 for 循环代替 np.linalg.norm()
def calculate_distances(input_vector, weights):
    # 提取weights数组的结构属性：深度、行数、列数
    rows, cols, _ = weights.shape
    # 定义一个纯0矩阵
    distances = np.zeros((rows, cols))
    for i in range(rows):
        for j in range(cols):
            # diff=第i层第j行的weights数据-input_vector
            # input_dim取到的是data数组的列数，所以第i层第j行的weights数据有input_dim数据
            # input_vector是从data的所有行里面随机提取的一行，列数=input_dim
            # diff=每一行的weights数据-input_vector
            # squared_diff=(weights数据-input_vector)的平方
            # sum_squared_diff=(weights数据-input_vector)的平方和
            # distances[i, j]是(weights数据-input_vector)的平方和再开方
            # 随着i和j的增加，diff会增加，distances[i, j]也会增加
            diff = weights[i, j] - input_vector
            squared_diff = diff ** 2
            sum_squared_diff = np.sum(squared_diff)
            distances[i, j] = np.sqrt(sum_squared_diff)
    return distances

【3.2.3】find_bmu()函数

# 找到最佳匹配单元（BMU）
def find_bmu(distances):
    # np.argmin(distances)求出distance的最小值
    # np.unravel_index返回distance的最小值在distance中的索引位置
    return np.unravel_index(np.argmin(distances), distances.shape)

【3.2.4】update_weights()函数

# 更新 BMU 及其邻域内神经元的权重
def update_weights(input_vector, bmu, weights, radius, learning_rate):
    # 提取weights数组的结构属性：深度、行数、列数
    rows, cols, _ = weights.shape
    for i in range(rows):
        for j in range(cols):
            # 计算当前神经元与 BMU 之间的距离
            dist_to_bmu = np.sqrt((i - bmu[0]) ** 2 + (j - bmu[1]) ** 2)
            if dist_to_bmu <= radius:
                # 计算邻域函数值
                influence = np.exp(-(dist_to_bmu ** 2) / (2 * radius ** 2))
                # 更新权重
                weights[i, j] += learning_rate * influence * (input_vector - weights[i, j])
    return weights

【3.2.5】SOM训练函数

# 训练 SOM
for iteration in range(max_iterations):
    # 随机选择一个输入向量
    # input_vector是从data的所有行里面随机提取的一行
    input_vector = data[np.random.randint(0, data.shape[0])]
    # 计算当前的学习率和邻域半径
    current_learning_rate = decay_function(initial_learning_rate, iteration, time_constant)
    current_radius = decay_function(initial_radius, iteration, time_constant)
    # 计算输入向量与所有神经元权重之间的距离
    distances = calculate_distances(input_vector, weights)
    # 找到 BMU
    bmu = find_bmu(distances)
    # 更新权重
    weights = update_weights(input_vector, bmu, weights, current_radius, current_learning_rate)

【3.3】SOM可视化

# 可视化 SOM 结果
plt.figure(figsize=(10, 10))
# 绘制数据点
plt.scatter(data[:, 0], data[:, 1], c='b', label='Data Points')
# 绘制 SOM 网格
for i in range(grid_size[0]):
    for j in range(grid_size[1]):
        # 绘制神经元的位置
        plt.scatter(weights[i, j, 0], weights[i, j, 1], c='r', s=100)
        # 绘制水平连接
        if j < grid_size[1] - 1:
            plt.plot([weights[i, j, 0], weights[i, j + 1, 0]],
                     [weights[i, j, 1], weights[i, j + 1, 1]], 'k-')
        # 绘制垂直连接
        if i < grid_size[0] - 1:
            plt.plot([weights[i, j, 0], weights[i + 1, j, 0]],
                     [weights[i, j, 1], weights[i + 1, j, 1]], 'k-')

plt.title('Self - Organizing Map')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend()
plt.show()

此时获得的完整代码为：

import numpy as np
import matplotlib.pyplot as plt

# 生成示例数据
# 这里我们生成 100行2列的位于[0,1)区间内，符合均匀分布的随机数
data = np.random.rand(100, 2)
#print(data)
# SOM 参数设置
# 输出层网格的大小（行数和列数）
# grid_size是存储数据的元组，不是矩阵
grid_size = (10, 10)
# 输入数据的维度
# input_dim取到的是data数组的列数
input_dim = data.shape[1]
# 最大迭代次数
max_iterations = 100
# 初始学习率
initial_learning_rate = 0.5
# 初始邻域半径
# 内置函数max()在元组grid_size中遍历每个元素，然后取出最大值
initial_radius = max(grid_size) / 2
# 时间常数，用于控制学习率和邻域半径的衰减速度
# 时间常数有多种定义方式，这是其中的一种
time_constant = max_iterations / np.log(initial_radius)

# 初始化 SOM 权重
# 权重矩阵的形状为 (行数, 列数, 输入维度)
# weights是一个grid_size[0]层，每一层的行列为(grid_size[1], input_dim)形式的矩阵
weights = np.random.rand(grid_size[0], grid_size[1], input_dim)
print('weights =',weights)
# 定义学习率和邻域半径的衰减函数
def decay_function(initial_value, iteration, time_constant):
    return initial_value * np.exp(-iteration / time_constant)

# 计算输入向量与所有神经元权重之间的欧氏距离
# 使用 for 循环代替 np.linalg.norm()
def calculate_distances(input_vector, weights):
    # 提取weights数组的结构属性：深度、行数、列数
    rows, cols, _ = weights.shape
    # 定义一个纯0矩阵
    distances = np.zeros((rows, cols))
    for i in range(rows):
        for j in range(cols):
            # diff=第i层第j行的weights数据-input_vector
            # input_dim取到的是data数组的列数，所以第i层第j行的weights数据有input_dim数据
            # input_vector是从data的所有行里面随机提取的一行，列数=input_dim
            # diff=每一行的weights数据-input_vector
            # squared_diff=(weights数据-input_vector)的平方
            # sum_squared_diff=(weights数据-input_vector)的平方和
            # distances[i, j]是(weights数据-input_vector)的平方和再开方
            # 随着i和j的增加，diff会增加，distances[i, j]也会增加
            diff = weights[i, j] - input_vector
            squared_diff = diff ** 2
            sum_squared_diff = np.sum(squared_diff)
            distances[i, j] = np.sqrt(sum_squared_diff)
    return distances

# 找到最佳匹配单元（BMU）
def find_bmu(distances):
    # np.argmin(distances)求出distance的最小值
    # np.unravel_index返回distance的最小值在distance中的索引位置
    return np.unravel_index(np.argmin(distances), distances.shape)

# 更新 BMU 及其邻域内神经元的权重
def update_weights(input_vector, bmu, weights, radius, learning_rate):
    # 提取weights数组的结构属性：深度、行数、列数
    rows, cols, _ = weights.shape
    for i in range(rows):
        for j in range(cols):
            # 计算当前神经元与 BMU 之间的距离
            dist_to_bmu = np.sqrt((i - bmu[0]) ** 2 + (j - bmu[1]) ** 2)
            if dist_to_bmu <= radius:
                # 计算邻域函数值
                influence = np.exp(-(dist_to_bmu ** 2) / (2 * radius ** 2))
                # 更新权重
                weights[i, j] += learning_rate * influence * (input_vector - weights[i, j])
    return weights

# 训练 SOM
for iteration in range(max_iterations):
    # 随机选择一个输入向量
    # input_vector是从data的所有行里面随机提取的一行
    input_vector = data[np.random.randint(0, data.shape[0])]
    # 计算当前的学习率和邻域半径
    current_learning_rate = decay_function(initial_learning_rate, iteration, time_constant)
    current_radius = decay_function(initial_radius, iteration, time_constant)
    # 计算输入向量与所有神经元权重之间的距离
    distances = calculate_distances(input_vector, weights)
    # 找到 BMU
    bmu = find_bmu(distances)
    # 更新权重
    weights = update_weights(input_vector, bmu, weights, current_radius, current_learning_rate)

# 可视化 SOM 结果
plt.figure(figsize=(10, 10))
# 绘制数据点
plt.scatter(data[:, 0], data[:, 1], c='b', label='Data Points')
# 绘制 SOM 网格
for i in range(grid_size[0]):
    for j in range(grid_size[1]):
        # 绘制神经元的位置
        plt.scatter(weights[i, j, 0], weights[i, j, 1], c='r', s=100)
        # 绘制水平连接
        if j < grid_size[1] - 1:
            plt.plot([weights[i, j, 0], weights[i, j + 1, 0]],
                     [weights[i, j, 1], weights[i, j + 1, 1]], 'k-')
        # 绘制垂直连接
        if i < grid_size[0] - 1:
            plt.plot([weights[i, j, 0], weights[i + 1, j, 0]],
                     [weights[i, j, 1], weights[i + 1, j, 1]], 'k-')

plt.title('Self - Organizing Map')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend()
plt.show()

代码运行获得的图像为：

++图1 SOM算法运行效果++

【4】算法分析

实际上，SOM 算法本身因为涉及索引操作，所以理解起来比较复杂。

在最初的理解层面：输入层的每一个元素都会直接作用到输出层的每一个元素。

需要再叠加一层：输入层和输出层的每一个位置索引都相关。

为便于理解，直接看核心的SOM 算法执行过程：

# 训练 SOM
# 这是实质的SOM 主函数
for iteration in range(max_iterations):
    # 随机选择一个输入向量
    # input_vector是从data的所有行里面随机提取的一行
    # 第一维度代表矩阵的行数，data.shape[0]获得data二维数组的行数
    # 由于每一次挑选input_vector都是随机的，所以存在全部data行都被选中的可能
    input_vector = data[np.random.randint(0, data.shape[0])]
    # 计算当前的学习率和邻域半径
    current_learning_rate = decay_function(initial_learning_rate, iteration, time_constant)
    current_radius = decay_function(initial_radius, iteration, time_constant)
    # 计算输入向量与所有神经元权重之间的距离
    distances = calculate_distances(input_vector, weights)
    # 找到 BMU
    # find_bmu函数是取出distances矩阵数组中最小的distances所在的位置索引
    # bmu只是位置函数
    bmu = find_bmu(distances)
    # 更新权重
    weights = update_weights(input_vector, bmu, weights, current_radius, current_learning_rate)

先取了input_vector数组，它是一个一维数组，是SOM算法的输入；

然后定义了学习率和领域半径，这两个参数的作用是用于调整权重向量weights；

在调整权重向量weights之前，需要计算输入和各个weights之间的距离；

距离计算完之后，需要获得最小距离对应的位置索引；

更新权重向量时，需要以最小距离所在的位置为参考，在一定的领域半径范围内才会对权重向量更新，否则就保持原值。

总结下来，先获得一个最小的输入量和weights量的差，然后在差最小，也就是最接近输入量的位置处，往周围拓展赋值。

按照这个思路理解，再回头去看各个子函数，对算法的理解会更深入。

文章里的代码使用了常规的for循环，而非已经成型的内置函数，读懂代码对理解SOM算法的本质意义有很大帮助。

【5】总结

学习了SOM算法的基本原理，使用python代码实现了SOM算法。