Tabla de contenido
(2) Muestreo (extracción de puntos de muestra)
(4) Cooperación y adaptación (actualización de los valores de peso)
3. Implementación del código Python
(2) Calcule la distancia topológica entre el punto de muestra y el vector de peso
1. Breve introducción de SOM
SOM (Self Organizing Map) red de mapas autoorganizados, también conocida como red neuronal competitiva. Se puede mostrar mapeando datos de alta dimensión en un espacio de baja dimensión con una estructura e interrelaciones simples, para realizar la visualización de datos, agrupamiento, clasificación y otras funciones.
La red SOM es diferente de otras redes neuronales. En comparación con otras redes neuronales, está más cerca del algoritmo de agrupamiento Kmeans, es decir, el algoritmo de agrupamiento K-means.
Su estructura se muestra en la siguiente figura.
En la figura se puede ver que cada nodo en la capa de salida está conectado al nodo de entrada a través de bordes de peso D (es decir, cada nodo en la capa de salida está representado por un peso Wij de dimensión D), y la relación entre cada uno El nodo en la capa de salida es Hay una cierta conexión según la distancia.
2. Proceso de formación SOM
(1) Inicialización
Elija valores aleatorios para el vector de peso inicial
(2) Muestreo (extracción de puntos de muestra)
Extraiga un punto de muestra de los datos de entrada como la muestra del vector de entrenamiento de entrada
(3) Competencia
Para los vectores de peso, las neuronas calculan sus respectivos valores de funciones discriminantes, que proporcionan la base para la competencia. La neurona particular con el valor de función discriminante más pequeño se declara ganadora. (La función discriminante se puede definir como la distancia euclidiana cuadrada entre la muestra del vector de entrenamiento de entrada y el vector de peso)
Vernáculo: calcule la distancia topológica entre cada neurona y los puntos de muestra de entrenamiento seleccionados en el segundo paso, y la distancia más cercana es el punto del vector de peso ganador (ganador)
(4) Cooperación y adaptación (actualización de los valores de peso)
En estudios neurobiológicos, hemos encontrado interacciones laterales dentro de un grupo de neuronas excitatorias. Cuando se activa una neurona, las vecinas más cercanas tienden a estar más excitadas que las más lejanas. Y existe una vecindad topológica que decae con la distancia.
La neurona ganadora en el paso anterior tendrá derecho a decidir el valor del peso. No solo la neurona ganadora obtiene actualizaciones de peso, sino que sus vecinas también obtienen sus pesos actualizados, aunque no tanto como la neurona ganadora.
Se puede entender que el nodo del vector de peso más cercano se mueve una cierta distancia al punto de muestra, y los nodos adyacentes también se mueven una cierta distancia.
(5) repetir
Vuelva al paso 2 y repita hasta que todos los puntos de datos de entrada coincidan
3. Implementación del código Python
(1) Inicialización
def __init__(self, X, output, iteration, batch_size):
"""
:param X: 形状是N*D， 输入样本有N个,每个D维
:param output: (n,m)一个元组，为输出层的形状是一个n*m的二维矩阵
:param iteration:迭代次数
:param batch_size:每次迭代时的样本数量
初始化一个权值矩阵，形状为D*(n*m)，即有n*m权值向量。权值由numpy随机函数生成。
"""
self.X = X
self.output = output
self.iteration = iteration
self.batch_size = batch_size
self.W = np.random.rand(X.shape[1], output[0] * output[1])
print(self.W.shape)(2) Calcule la distancia topológica entre el punto de muestra y el vector de peso
def GetN(self, t):
"""
:param t:时间t, 这里用迭代次数来表示时间
:return: 返回一个整数，表示拓扑距离，时间越大，拓扑邻域越小
"""
a = min(self.output)
return int(a - float(a) * t / self.iteration)
def Geteta(self, t, n):
"""
:param t: 时间t, 这里用迭代次数来表示时间
:param n: 拓扑距离
:return: 返回学习率，
"""
return np.power(np.e, -n) / (t + 2)(3) Competencia
def train(self):
"""
train_Y:训练样本与形状为batch_size*(n*m)
winner:一个一维向量，batch_size个获胜神经元的下标
:return:返回值是调整后的W
"""
count = 0
while self.iteration > count:
train_X = self.X[np.random.choice(self.X.shape[0], self.batch_size)]
normal_W(self.W)
normal_X(train_X)
train_Y = train_X.dot(self.W)
winner = np.argmax(train_Y, axis=1).tolist()
self.updata_W(train_X, count, winner)
count += 1
return self.W
def train_result(self):
normal_X(self.X)
train_Y = self.X.dot(self.W)
winner = np.argmax(train_Y, axis=1).tolist()
print(winner)
return winner(4) Actualizar pesos
def updata_W(self, X, t, winner):
N = self.GetN(t)
for x, i in enumerate(winner):
to_update = self.getneighbor(i[0], N)
for j in range(N + 1):
e = self.Geteta(t, j)
for w in to_update[j]:
self.W[:, w] = np.add(self.W[:, w], e * (X[x, :] - self.W[:, w]))
def getneighbor(self, index, N):
"""
:param index:获胜神经元的下标
:param N: 邻域半径
:return ans: 返回一个集合列表，分别是不同邻域半径内需要更新的神经元坐标
"""
a, b = self.output
length = a * b
def distence(index1, index2):
i1_a, i1_b = index1 // a, index1 % b
i2_a, i2_b = index2 // a, index2 % b
return np.abs(i1_a - i2_a), np.abs(i1_b - i2_b)
ans = [set() for i in range(N + 1)]
for i in range(length):
dist_a, dist_b = distence(i, index)
if dist_a <= N and dist_b <= N: ans[max(dist_a, dist_b)].add(i)
return ans