自组织映射Python实现
自组织映射（Self-organizing map）Python实现。仅供学习。
#!/usr/bin/env python3
"""
Self-organizing map
"""
from math import exp
import toolz
import numpy as np
import numpy.linalg as LA
from sklearn.base import ClusterMixin
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
class Node:
"""Node
Attributes:
location (np.ndarray): location of the node
weight (np.ndarray): weight of the node, in the data sp.
"""
def __init__(self, weight, location=None):
self.weight = weight
self.location = location
def normalize(self):
return self.weight / LA.norm(self.weight)
def output(self, x):
# similarity between the node and the input `x`
return LA.norm(x - self.weight)
def near(self, other, d=0.2):
# judge the neighborhood of the nodes by locations
if self.location is not None and other.location is not None:
return LA.norm(self.location - other.location) < d
else:
return 0
def update(self, x, eta=0.1):
"""update the weight of the node
w += r (x-w)
"""
self.weight += eta *(x - self.weight)
@staticmethod
def random(n=2):
weight = np.random.random(n)
location = np.random.random(2)
node = Node(weight, location)
node.normalize()
return node
def plot(self, axes, i1=0, i2=1, *args, **kwargs):
x1, x2 = self.weight[i1], self.weight[i2]
axes.plot(x1, x2, *args, **kwargs)
class Layer(ClusterMixin):
"""
Layer of SOM
A Grid of nodes
"""
def __init__(self, nodes):
self.nodes = list(nodes)
@staticmethod
def random(n_nodes=100, *args, **kwargs):
return Layer([Node.random(*args, **kwargs) for _ in range(n_nodes)])
def output(self, x):
# all outputs(similarity to x) of the nodes
return [node.output(x) for node in self.nodes]
def champer(self, x):
"""champer node: best matching unit (BMU)
"""
return self.nodes[self.predict(x)]
def predict(self, x):
"""the index of best matching unit (BMU)
"""
return np.argmin(self.output(x))
def update(self, x, eta=0.5, d=0.5):
# update the nerighors of the best node
c = self.champer(x)
for node in self.nodes:
if node.near(c, d):
node.update(x, eta)
def plot(self, axes, i1=0, i2=1, *args, **kwargs):
x1 = [node.weight[i1] for node in self.nodes]
x2 = [node.weight[i2] for node in self.nodes]
axes.scatter(x1, x2, *args, **kwargs)
def fit(self, data, eta=0.2, d=0.2, max_iter=100):
data = scaler.fit_transform(data)
for t in range(max_iter):
for x in data:
self.update(x, eta=eta*exp(-t/10), d=d*exp(-t/10))
if __name__ == '__main__':
try:
import pandas as pd
df = pd.read_csv('heart.csv') # input your data
except Exception as e:
printe(e)
raise Exception('Please input your data!')
def _grid(size=(5, 5), *args, **kwargs):
grid = []
r, c = size
for k in range(1,r):
row = []
for l in range(1,c):
weight = np.array((k/r, l/c))
# weight = np.random.random(kwargs['dim']) # for randomly generating
location = np.array((k/r, l/c))
node = Node(weight=weight, location=location)
row.append(node)
grid.append(row)
return grid
df = df[['trestbps', 'chol']]
N, p = df.shape
X = df.values.astype('float')
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111)
X_ = scaler.fit_transform(X)
ax.plot(X_[:,0], X_[:,1], 'o')
g = _grid(size=(5,5), dim=p)
for row in g:
x = [node.weight[0] for node in row]
y = [node.weight[1] for node in row]
ax.plot(x, y, 'g--')
for col in zip(*g):
x = [node.weight[0] for node in col]
y = [node.weight[1] for node in col]
ax.plot(x, y, 'g--')
l = Layer(nodes=toolz.concat(g))
l.plot(ax, marker='s', color='g', alpha=0.2)
l.fit(X[:N//2,:], max_iter=50)
l.plot(ax, marker='+', color='r')
for row in g:
x = [node.weight[0] for node in row]
y = [node.weight[1] for node in row]
ax.plot(x, y, 'r')
for col in zip(*g):
x = [node.weight[0] for node in col]
y = [node.weight[1] for node in col]
ax.plot(x, y, 'r')
ax.set_title('Demo of SOM')
ax.legend(('Data', 'Initial nodes', 'Terminal nodes'))
plt.show()
