机器学习之自组织特征映射神经网络（SOM）python实现

最新推荐文章于 2022-05-20 17:11:18 发布
最新推荐文章于 2022-05-20 17:11:18 发布
阅读量1.2w 收藏 70
点赞数 7
分类专栏： 机器学习 文章标签： 机器学习

下面为两种SOM的运行代码，用来分类同样的数据，第一种学习率和聚类半径随着迭代次数的变化而变化，参考机器学习之自组织特征映射神经网络（SOM），同时运行博客点这里的代码，比较运行时间，都设置迭代次数为1000次，分4类，运行时间分为为0(即小于1s)和17s。
两种方式的归一化方法不一样。一个是维度归一化，一个是一般的归一化（行向量）

代码1

from numpy import *
import matplotlib.pyplot as plt
import string

class Kohonen(object):
    def __init__(self):
        self.lratemax=0.8   #最大学习率-欧式距离
        self.lratemin=0.05  #最小学习率-欧式距离
        self.rmax=5         #最大聚类半径--根据数据集
        self.rmin=0.5       #最小聚类半径--根据数据集
        self.Steps=1000     #迭代次数
        self.lratelist=[]   #学习率收敛曲线
        self.rlist=[]       #学习率半径曲线
        self.w=[]           #权重向量组
        self.M=2            # M*N表示聚类总数
        self.N=2            #M、N表示邻域的参数
        self.dataMat=[]     #外部导入数据集
        self.classLabel=[]  #聚类后的类别标签

    def loadDate(self,fileName):  #加载数据文件
        fr=open(fileName)
        for line in fr.readlines():
            curLine=line.strip().split("\t")
            lineArr=[]
            lineArr.append(float(curLine[0]))
            lineArr.append(float(curLine[1]))
            self.dataMat.append(lineArr)
        self.dataMat=mat(self.dataMat)

    def file2matrix(self,path, delimiter):
        recordlist = []
        fp = open(path)
        content = fp.read()
        fp.close()
        rowlist = content.splitlines()  # 按行转换为一维表
        # 逐行遍历      # 结果按分隔符分割为行向量
        recordlist = [map(eval, row.split(delimiter)) for row in rowlist if row.strip()]
        # 返回转换后的矩阵形式
        self.dataMat = mat(recordlist)

    def normalize(self,dataMat):
        [m,n]=shape(dataMat)
        for i in xrange(n):
           dataMat[:,i] =(dataMat[:,i]-mean(dataMat[:,]))/std(dataMat[:,])
        return dataMat

    def distEclud(self,matA,matB):
        ma, na = shape(matA);
        mb, nb = shape(matB);
        rtnmat = zeros((ma, nb))
        for i in xrange(ma):
            for j in xrange(nb):
                rtnmat[i, j] = linalg.norm(matA[i, :] - matB[:, j].T)
        return rtnmat

    def init_grid(self): #初始化第二层网格
        [m, n] = shape(self.dataMat)
        k=0 #构建低二层网络模型
        #数据集的维度即网格的维度，分类的个数即网格的行数
        grid=mat(zeros((self.M*self.N,n)))
        for i in xrange(self.M):
            for j in xrange(self.N):
                grid[k,:]=[i,j]
                k+=1
        return grid
    def ratecalc(self,i):
        lrate = self.lratemax - (i + 1.0) * (self.lratemax - self.lratemin) / self.Steps
        r = self.rmax - ((i + 1.0) * (self.rmax - self.rmin)) / self.Steps
        return lrate,r

    #主程序
    def train(self):
        #1.构建输入层网络
        dm,dn=shape(self.dataMat)
        #归一化数据
        normDataSet=self.normalize(self.dataMat)
        #2.初始化第二层分类网络
        grid=self.init_grid()
        #3.随机初始化两层之间的权重向量
        self.w=random.rand(dn,self.M*self.N)
        distM=self.distEclud  #确定距离公式
        #4.迭代求解
        if self.Steps<5*dm:self.Steps=5*dm  #设定最小迭代次数
        for i in xrange(self.Steps):
            lrate,r=self.ratecalc(i) #1.计算当前迭代次数下的学习率和学习聚类半径
            self.lratelist.append(lrate);self.rlist.append(r)
            #2.随机生成样本索引，并抽取一个样本
            k=random.randint(0,dm)
            mySample=normDataSet[k,:]
            #3.计算最优节点：返回最小距离的索引值
            minIndx=(distM(mySample,self.w)).argmin()
            #4.计算领域
            d1=ceil(minIndx/self.M)  #计算此节点在第二层矩阵中的位置
            d2=mod(minIndx,self.M)
            distMat=distM(mat([d1,d2]),grid.T)
            nodelindx=(distMat<r).nonzero()[1] #获取领域内的所有点
            for j in xrange(shape(self.w)[1]):
                if sum(nodelindx==j):
                    self.w[:,j]=self.w[:,j]+lrate*(mySample[0]-self.w[:,j])
        #主循环结束

        self.classLabel=range(dm) #分配和存储聚类后的类别标签
        for i in xrange(dm):
            self.classLabel[i]=distM(normDataSet[i,:],self.w).argmin()
        self.classLabel=mat(self.classLabel)

    def showCluster(self,plt): #绘图
        lst=unique(self.classLabel.tolist()[0]) #去重
        i=0
        for cindx in lst:
            myclass = nonzero(self.classLabel==cindx)[1]
            xx=self.dataMat[myclass].copy()
            if i==0: plt.plot(xx[:,0],xx[:,1],'bo')
            elif i==1:plt.plot(xx[:,0],xx[:,1],'rd')
            elif i==2:plt.plot(xx[:,0],xx[:,1],'gD')
            elif i==3:plt.plot(xx[:,0],xx[:,1],'c^')
            i+=1
        plt.show()

if __name__=="__main__":

    SOMNet=Kohonen()
    SOMNet.loadDate('dataset2.txt')
    SOMNet.train()
    SOMNet.showCluster(plt)

这里写代码片

代码2

参考：http://blog.csdn.net/chenge_j/article/details/72537568

from numpy import *
import matplotlib.pyplot as plt
from  numpy import linalg

#初始化输入层与竞争层神经元的连接权值矩阵
def initCompetition(n , m , d):
    #随机产生0-1之间的数作为权值
    array = random.random(size=n * m *d)
    com_weight = array.reshape(n,m,d)
    return com_weight

#计算向量的二范数
def cal2NF(X):
    res = 0
   # return linalg.norm(X)
    for x in X:
        res += x*x
    return res ** 0.5

#对数据集进行归一化处理
def normalize(dataSet):
    old_dataSet = copy(dataSet)
    for data in dataSet:
        two_NF = cal2NF(data)
        for i in range(len(data)):
            data[i] = data[i] / two_NF
    return dataSet , old_dataSet
#对权值矩阵进行归一化处理
def normalize_weight(com_weight):
    for x in com_weight:
        for data in x:
            two_NF = cal2NF(data)
            for i in range(len(data)):
                data[i] = data[i] / two_NF
    return com_weight

#得到获胜神经元的索引值
def getWinner(data , com_weight):
    max_sim = 0
    n,m,d = shape(com_weight)
    mark_n = 0
    mark_m = 0
    for i in range(n):
        for j in range(m):
            if sum(data * com_weight[i,j]) > max_sim:
                max_sim = sum(data * com_weight[i,j])
                mark_n = i
                mark_m = j
    return mark_n , mark_m

#得到神经元的N邻域
def getNeibor(n , m , N_neibor , com_weight):
    res = []
    nn,mm , _ = shape(com_weight)
    for i in range(nn):
        for j in range(mm):
            N = int(((i-n)**2+(j-m)**2)**0.5)
            if N<=N_neibor:
                res.append((i,j,N))
    return res

#学习率函数
def eta(t,N):
    return (0.3/(t+1))* (math.e ** -N)

#SOM算法的实现

'''
T:最大迭代次数
N_neibor:初始近邻数
'''
def do_som(dataSet , com_weight, T , N_neibor):
    for t in range(T-1):
        com_weight = normalize_weight(com_weight)
        for data in dataSet:
            n , m = getWinner(data , com_weight)
            neibor = getNeibor(n , m , N_neibor , com_weight)
            for x in neibor:
                j_n=x[0];j_m=x[1];N=x[2]
                #权值调整
                com_weight[j_n][j_m] = com_weight[j_n][j_m] + eta(t,N)*(data - com_weight[j_n][j_m])
            N_neibor = N_neibor+1-(t+1)/200
    res = {}
    N , M , _ =shape(com_weight)
    for i in range(len(dataSet)):
        n, m = getWinner(dataSet[i], com_weight)
        key = n*M + m
        if res.has_key(key):
            res[key].append(i)
        else:
            res[key] = []
            res[key].append(i)
    return res

def draw(C , dataSet):
    color = ['r', 'y', 'g', 'b', 'c', 'k', 'm' , 'd']
    count = 0
    for i in C.keys():
        X = []
        Y = []
        datas = C[i]
        for j in range(len(datas)):
            X.append(dataSet[datas[j]][0])
            Y.append(dataSet[datas[j]][1])
        plt.scatter(X, Y, marker='o', color=color[count % len(color)], label=i)
        count += 1
    plt.legend(loc='upper right')
    plt.show()

def loadDataSet(fileName):  # 加载数据文件
    fr = open(fileName)
    dataMat=[]
    for line in fr.readlines():
        curLine = line.strip().split(",")
        lineArr = []
        lineArr.append(float(curLine[0]))
        lineArr.append(float(curLine[1]))
        dataMat.append(lineArr)
    dataMat = mat(dataMat)
    return dataMat

def file2matrix(path, delimiter):
    recordlist = []
    fp = open(path, "rb")  # 读取文件内容
    content = fp.read()
    fp.close()
    rowlist = content.splitlines()  # 按行转换为一维表
     # 逐行遍历         # 结果按分隔符分割为行向量
    recordlist = [map(eval, row.split(delimiter)) for row in rowlist if row.strip()]
        # 返回转换后的矩阵形式
    return recordlist
 # SOM算法主方法
def SOM(dataSet,com_n,com_m,T,N_neibor):
    dataSet, old_dataSet = normalize(dataSet)
    com_weight = initCompetition(com_n,com_m,shape(dataSet)[1])
    C_res = do_som(dataSet, com_weight, T, N_neibor)
    draw(C_res, dataSet)
    draw(C_res, old_dataSet)


starttime = datetime.datetime.now()
dataSet = file2matrix("dataset2.txt",'\t')
SOM(dataSet,2,2,1000,2)
endtime = datetime.datetime.now()
print (endtime - starttime).seconds

这里写图片描述

参考：http://blog.csdn.net/chenge_j/article/details/72537568

小亚文
关注
专栏目录
一切皆是映射：从零开始构建深度学习架构
AI架构设计之禅
09-29 878
一切皆是映射：从零开始构建深度学习架构 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming 1. 背景介绍 1.1 问题的由来 深度学习作为人工智能领域最热门的技
聚类算法——python实现SOM算法
热门推荐
和服务器度过的夏天
05-18 2万+
算法简介SOM网络是一种竞争学习型的无监督神经网络，将高维空间中相似的样本点映射到网络输出层中的邻近神经元。训练过程简述：在接收到训练样本后，每个输出层神经元会计算该样本与自身携带的权向量之间的距离，距离最近的神经元成为竞争获胜者，称为最佳匹配单元。然后最佳匹配单元及其邻近的神经元的权向量将被调整，以使得这些权向量与当前输入样本的距离缩小。这个过程不断迭代，直至收敛。网络结构：输入层和输出层（或竞争
python实现SOM算法
09-20
主要为大家详细介绍了python实现SOM算法，聚类算法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
深度学习 自组织映射网络 ——python实现SOM（用于聚类）
Cyrus_May的博客
01-13 1万+
深度学习 自组织映射网络 ——python实现SOM（用于聚类）摘要python实现代码计算实例 摘要 SOM（Self Organizing Maps ） 的目标是用低维目标空间的点来表示高维空间中的点，并且尽可能保持对应点的距离和邻近关系（拓扑关系）。该算法可用于降维和聚类等方面，本文通过python实现了该算法在聚类方面的应用，并将代码进行了封装，方便读者调用。 下图为正文计算实例的可视化图形。 python实现代码 net：竞争层的拓扑结构，支持一维及二维，1表示该输出节点存在，0表示不存在该输出
自组织映射网络 ——python实现SOM（用于聚类）
01-13
SOM（Self Organizing Maps ） 的目标是用低维目标空间的点来表示高维空间中的点，并且尽可能保持对应点的距离和邻近关系（拓扑关系）。该算法可用于降维和聚类等方面，此代码主要用于实现聚类。
SOM算法，Python源代码实现
04-29
利用SOM算法实现聚类分析，Python代码实现。结果图标展示。
机器学习算法与Python实践(7) - 自组织映射算法(SOM)
_提拉米苏的博客
11-24 1万+
自组织映射算法（Self-Organizing Map ， SOM） SOM网络是一种竞争学习型的无监督神经网络，将高维空间中相似的样本点映射到网络输出层中的邻近神经元，属于聚类算法。
som-master_som神经网络_python_
10-04
在描述中提到的“Python实现SOM自组织神经网络算法”，可能包含了编写SOM的完整流程，包括数据预处理、网络构建、训练过程和结果可视化。这可能涉及到对Python编程的基本理解，对SOM算法的理解，以及如何利用Python...
基于Python实现的使用自组织映射SOM解决旅行商问题.zip
最新发布
05-11
在本项目中，使用了Python编程语言来解决旅行商问题，具体采用了一种名为自组织映射（Self-Organizing Map, SOM）的神经网络模型。SOM是一种无监督学习方法，由Kohonen在1982年提出，用于数据可视化和降维。它通过...
SOM.rar_som聚类_无监督学习_竞争神经网络_自组织神经网络
09-24
自组织映射（Self-Organizing Map，简称SOM）是一种无监督学习的神经网络模型，由芬兰科学家Teuvo Kohonen在20世纪80年代提出。这种网络主要用于数据的降维和可视化，尤其适用于非线性数据的聚类分析。在" SOM.rar_...
SOM神经网络、LVQ神经网络、CPN神经网络与Python实现
qq_41858347的博客
02-26 4368
竞争型学习神经网络 简述 最近对神经网络比较感兴趣，因此花了两三天时间对整个领域进行了简单的调研，梳理和学习。其中深度学习，尤其以我们熟悉的如今大火的深度网络模型,如CNN, RNN, GAN和AE及它们的子类等；是在本世纪初，硬件性能达到了一个新的高度后才能有如此巨大的发展的。事实上在21世纪之前，各种各样的神经网络模型已经被发明并应用。那时候由于硬件性能的限制，以及由通信网络不发达导致的数据量...
训练som自组织特征映射神经网络的源代码
04-17
训练som自组织特征映射神经网络的源代码，这是一种很常用很实用的神经网络，不下会后悔的~
som_python
08-12
使用python编写的SOM神经网络代码，测试可用，内含测试数据文件
SOM聚类算法
07-18
直接可用的SOM聚类matlab代码
sommatlab代码-lsom:Python中的轻型自组织图（SOM，又称Kohonen地图）
05-26
som matlab代码尔索姆 Python中的轻型自组织图（SOM，又称Kohonen地图） 对于在巴黎UPMC的LOCEAN的研究项目，我需要在Python中使用SOM。 Matlab（）中提供了一个巨大的工具箱，但是我很难找到适合我需求的Python包（一个轻便但灵活的方法，它经过多步培训，经过很好的注释，可以在运行时更改参数批量学习）。 我决定编写所需的代码，并在此处共享，希望它对某人有用。 这是一个示例代码，文件中的注释应足够完整： from lsom import * X = np.concatenate((np.random.rand(100,3) , np.random.rand(100,3)+np.asarray([1,1,1]))) (vap, vepu, pc) = pca(X) koh = SOM((5,5), 3, hexagonal=True, init_fun=init_koh_pca(vap, 200, (5,5)) ) koh.train(pc, niter=30, lrate=.9, iradius=5) koh.quality(pc) draw_k
机器学习算法——神经网络6（SOM网络）
Vicky_xiduoduo的博客
05-20 6993
SOM（Self-Organizing Map,自组织映射）网络也是一种竞争学习型的无监督神经网络。 它能将高维数据映射到低维空间（通常为二维），同时保持输入数据在高维空间的拓扑结构，即将高维数据中相似的样本点映射到网络输出层中的邻近神经元。 SOM网络结构为： 输入层神经元的数量是由输入向量的维度决定的，一个神经元对应一个特征。 SOM网络结构的区别主要在竞争层：可以有1维、2维（最常见）。竞争层也可以有更高的维度，不过处于可视化的目的，高维竞争层用的比较少。 其中二维平面有2种平面结构
SOM自组织（竞争型）神经网络（Python实现）
阿伟的博客
03-09 5384
SOM自组织（竞争型）神经网络
⚡自组织映射（SOM）神经网络⚡Python实现 |Python技能树征题
车手只需要车和手，压力来自轮胎
09-06 2045
❤九月❤份了，车神哥又回归了校园 ❉冬天❉还会远吗 ♪推荐一首最近很⚡喜欢⚡的歌♪ ❀No Fear In My Heart -朴树❀ 由于最近在写一篇相关的论文，就说说其中遇到的一些问题吧~ Minisom 之前做过一个对minisom的第三方开源库的介绍，可以点击看这里。 对相应的代码添加了注释： 导入各种库吧 # 导入库 from sklearn.model_selection import train_test_split from s.
som神经网络python源代码
09-05
som神经网络，即自组织映射（Self-Organizing Map），是一种无监督学习的神经网络算法，用于聚类和数据降维。下面是一个基于Python的简单som神经网络的代码示例： ```python import numpy as np class SOM: def __init__(self, input_dim, output_dim, learning_rate=0.2, num_iterations=100): self.input_dim = input_dim self.output_dim = output_dim self.learning_rate = learning_rate self.num_iterations = num_iterations self.weights = np.random.rand(output_dim[0], output_dim[1], input_dim) def train(self, input_data): for iteration in range(self.num_iterations): for data_point in input_data: bmu_idx = self.find_best_matching_unit(data_point) self.update_weights(data_point, bmu_idx, iteration) def find_best_matching_unit(self, data_point): min_dist = np.inf bmu_idx = (0, 0) for i in range(self.output_dim[0]): for j in range(self.output_dim[1]): dist = np.linalg.norm(data_point - self.weights[i, j]) if dist < min_dist: min_dist = dist bmu_idx = (i, j) return bmu_idx def update_weights(self, data_point, bmu_idx, iteration): for i in range(self.output_dim[0]): for j in range(self.output_dim[1]): dist_to_bmu = np.linalg.norm(np.array(bmu_idx) - np.array([i, j])) lr = self.learning_rate * (1 - iteration / self.num_iterations) influence = np.exp(-dist_to_bmu / (lr * iteration)) self.weights[i, j] += lr * influence * (data_point - self.weights[i, j]) def predict(self, input_data): output = np.zeros(input_data.shape[0]) for i, data_point in enumerate(input_data): bmu_idx = self.find_best_matching_unit(data_point) output[i] = bmu_idx[0] * self.output_dim[1] + bmu_idx[1] return output # 示例用法 input_data = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]) som = SOM(input_dim=2, output_dim=(10, 10)) som.train(input_data) test_data = np.array([[2.0, 3.0], [4.0, 5.0]]) predicted = som.predict(test_data) print(predicted) ``` 这里的SOM类有几个关键的方法和属性： - `__init__`：初始化方法，定义了输入维度、输出维度、学习率和迭代次数，并初始化权重矩阵。 - `train`：训练方法，通过迭代更新权重矩阵。 - `find_best_matching_unit`：寻找最佳匹配单元方法，在输出层中寻找与输入数据点最相似的神经元。 - `update_weights`：更新权重方法，根据输入数据点和最佳匹配单元更新权重矩阵。 - `predict`：预测方法，根据输入数据点，返回最佳匹配单元的位置。 示例中使用一个简单的二维数据集进行训练，并通过`predict`方法预测测试数据点的最佳匹配单元位置。 这是一个简单的som神经网络python源代码示例，可以根据需要进行修改和扩展。
评论 25
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值