【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算法。
