正文

郑捷《机器学习算法原理与编程实践》学习笔记（第六章神经网络初步）6.5boltzmann机算法

金秀  金秀  2022-08-22  628

关键词：

6.5 Boltzmann机算法

6.5.1 问题的提出

6.5.2 模拟退化原理

6.5.3 Boltzmann分布与退火过程

6.5.4Boltzmann机类与退火过程

　　Boltzmann网络初始时，需要根据参数设置一系列的初始值，主要参数在_init_中

　　（1）构造方法如下

class BoltzmannNet(object):
    def __init__(self):
        self.dataMat   = []        #外部导入的数据集
        self.MAX_ITER  = 2000      #外循环迭代次数
        Self.T0        = 1 000     #最高温度：这个温度变化范围应位于最大迭代范围
        self.Lambda    = 0.97      #温度下降参数
        self.iteration = 0         #达到最优时的迭代次数
        self.dist      = []        #存储生成的距离
        self.pathindx  = []        #存储生成的路径索引
        self.bestdist  = 0         #生成的最优路径长度
        self.bestpath  = []        #生成的最优路径

　　（2）加载数据文件类

 def loadDataSet(self,filename):     #加载数据集
        self.dataMat     = []
        self.classLabels = []
        fr               = open(filename)
        for line in fr.readlines():
            lineArr = line.strip().split()
            self.dataMat.append([float(lineArr[0]),float(lineArr[1]),1.0])
            self.classLabels.append(int(float(lineArr[2])))
        self.dataMat = mat(self.dataMat)
        m,n          = shape(self.dataMat)
        self.nSampNum = m   #样本数量
        self.nSampDim = n-1 #样本维度

　　（3）计算矩阵各向量之间的距离--欧式距离

 def distEclud(self,vecA,vecB):
        #欧式距离
        eps = 1.0e-6
        return linalg.norm(vecA-vecB) + eps

　　（4）玻耳兹曼函数

 def boltzmann(self,new1,old1,T):
        return exp(-(new1-old1)/T)

　　（5）计算路径长度

 def pathLen(self,dist,path):
        N = len(path)
        plen = 0
        for i in xrange(0,N-1):   #长度为N的向量，包含1~N的整数
            plen += dist[path[i],path[i+1]]
        plen += dist[path[0],path[N-1]]
        return  plen

　　（6）交换新旧路径

 def changePath(self,old_path):
        N = len(old_path)
        if random.rand() < 0.25:   #产生两个位置，并交换
            chpos = floor(random.rand(1,2)*N).tolist()[0]
            new_path = copy.deepcopy(old_path)
            new_path[int(chpos[0])] = old_path[int(chpos[1])]
            new_path[int(chpos[1])] = old_path[int(chpos[0])]
        else:
            d = ceil(random.rand(1,3)*N).tolist()[0]
            d.sort()  #随机路径排序
            a = int(d[0])
            b = int(d[1])
            c = int(d[2])
        if a != b and b != c:
            new_path = copy.deepcopy(old_path)
            new_path[a,c-1] = old_path[b-1:c-1]+old_path[a:b-1]
        else:
            new_path = self.changePath(old_path)
        return new_path

　　（7）绘制路径

def drawPath(self,Seq,dataMat,color = ‘b‘):
        m,n = shape(dataMat)
        px  = (dataMat[Seq,0]).tolist()
        py  = (dataMat[Seq,1]).tolist()
        px.append(px[0])
        py.append(py[0])
        plt.plot(px,py,color)

　　（8）绘制散点图

def drawScatter(self,plt):
        px = (self.dataMat[:,0]).tolist()
        py = (self.dataMat[:,1]).tolist()
        plt.scatter(px,py,c = ‘green‘,marker = ‘o‘,s = 60)
        i = 65
        for x,y in zip(px,py):
            plt.annotate(str(chr(i)),xy = (x[0]+40,y[0]),color = ‘black‘)
            i += 1

　　（9）绘制趋势线

  def Trendline(self,plt,color = ‘b‘):
        plt.plot(range(len(self.dist)),self.dist,color)

6.5.5 最短路径的实现

　　Boltzmann网络的具体运行步骤如下

　　第一步：导入数据，并根据配置参数初始化网络

　　初始化网络函数如下：

    def initBMNet(self,m,n,distMat):
        self.pathindx = range(m)
        random.shuffle(self.pathindx)  #随机生成每个路径
        self.dist.append(self.pathLen(distMat,self.pathindx)) #每个路径对应的距离
        return self.T0,self.pathindx,m

#第一步：导入数据，并根据配置参数初始化网络
    def train(self):  #主函数
        [m,n] = shape(self.dataMat)
        distMat = self.distEclud(self.dataMat,self.dataMat.T) #转换为邻接矩阵（距离矩阵）
        # T为当前温度，curpath为当前路径索引，MAX_M为内循环最大迭代次数
        [T,curpath,MAX_M] = self.initBMNet(m,n,distMat)

    #进入主循环，计算最优路径
        step = 0 #初始化外循环迭代
        while step <= self.MAX_ITER:   #外循环
            m = 0                       #内循环计数器
            while m <= MAX_M:          #内循环
                curdist = self.pathLen(distMat,curpath) #计算当前路径距离
                newpath = self.changePath(curpath)      #交换产生新路径
                newdist = self.pathLen(distMat,newpath) #计算新路径距离
                #判断网络是否是一个局部稳态
                if (curdist > newdist):
                    curpath = newpath
                    self.pathindx.append(curpath)
                    self.dist.append(newdist)
                    self.iteration += 1       #增加迭代次数
                else:                         #如果网络处于局部稳定状态，则执行玻尔兹曼函数
                    if random.rand()<self.boltzmann(newdist,curdist,T):
                        curpath = newpath
                        self.pathindx.append(curpath)
                        self.dist.append(newdist)
                        self.iteration += 1   #增加迭代次数
            m += 1
            step += 1
            T = T *self.Lambda   #降温，返回迭代，直至算法终止
    #第三步：提取最优路径
        self.bestdist = min(self.dist)
        indxes = argmin(self.dist)
        self.bestdist = self.pathindx[indxes]

6.5.6 执行算法

bmNet = BoltzmannNet()
bmNet.loadDataSet("dataSet25.txt")
bmNet.train()
print u"循环迭代",bmNet.bestdist
print  u"最佳路线",bmNet.bestpath
#显示优化后的城市地图、路径图
bmNet.drawScatter(plt)
plt.show()

bmNet.Trendline(plt) #绘制误差算法收敛曲线
plt.show()

全部代码：

#coding:utf-8

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

class BoltzmannNet(object):
    def __init__(self):
        self.dataMat   = []        #外部导入的数据集
        self.MAX_ITER  = 2000      #外循环迭代次数
        Self.T0        = 1 000     #最高温度：这个温度变化范围应位于最大迭代范围
        self.Lambda    = 0.97      #温度下降参数
        self.iteration = 0         #达到最优时的迭代次数
        self.dist      = []        #存储生成的距离
        self.pathindx  = []        #存储生成的路径索引
        self.bestdist  = 0         #生成的最优路径长度
        self.bestpath  = []        #生成的最优路径

    def loadDataSet(self,filename):     #加载数据集
        self.dataMat     = []
        self.classLabels = []
        fr               = open(filename)
        for line in fr.readlines():
            lineArr = line.strip().split()
            self.dataMat.append([float(lineArr[0]),float(lineArr[1]),1.0])
            self.classLabels.append(int(float(lineArr[2])))
        self.dataMat = mat(self.dataMat)
        m,n          = shape(self.dataMat)
        self.nSampNum = m   #样本数量
        self.nSampDim = n-1 #样本维度

    def distEclud(self,vecA,vecB):
        #欧式距离
        eps = 1.0e-6
        return linalg.norm(vecA-vecB) + eps

    def boltzmann(self,new1,old1,T):
        return exp(-(new1-old1)/T)

    def pathLen(self,dist,path):
        N = len(path)
        plen = 0
        for i in xrange(0,N-1):   #长度为N的向量，包含1~N的整数
            plen += dist[path[i],path[i+1]]
        plen += dist[path[0],path[N-1]]
        return  plen

    def changePath(self,old_path):
        N = len(old_path)
        if random.rand() < 0.25:   #产生两个位置，并交换
            chpos = floor(random.rand(1,2)*N).tolist()[0]
            new_path = copy.deepcopy(old_path)
            new_path[int(chpos[0])] = old_path[int(chpos[1])]
            new_path[int(chpos[1])] = old_path[int(chpos[0])]
        else:
            d = ceil(random.rand(1,3)*N).tolist()[0]
            d.sort()  #随机路径排序
            a = int(d[0])
            b = int(d[1])
            c = int(d[2])
        if a != b and b != c:
            new_path = copy.deepcopy(old_path)
            new_path[a,c-1] = old_path[b-1:c-1]+old_path[a:b-1]
        else:
            new_path = self.changePath(old_path)
        return new_path

    def drawPath(self,Seq,dataMat,color = ‘b‘):
        m,n = shape(dataMat)
        px  = (dataMat[Seq,0]).tolist()
        py  = (dataMat[Seq,1]).tolist()
        px.append(px[0])
        py.append(py[0])
        plt.plot(px,py,color)

    def drawScatter(self,plt):
        px = (self.dataMat[:,0]).tolist()
        py = (self.dataMat[:,1]).tolist()
        plt.scatter(px,py,c = ‘green‘,marker = ‘o‘,s = 60)
        i = 65
        for x,y in zip(px,py):
            plt.annotate(str(chr(i)),xy = (x[0]+40,y[0]),color = ‘black‘)
            i += 1

    def Trendline(self,plt,color = ‘b‘):
        plt.plot(range(len(self.dist)),self.dist,color)

    def initBMNet(self,m,n,distMat):
        self.pathindx = range(m)
        random.shuffle(self.pathindx)  #随机生成每个路径
        self.dist.append(self.pathLen(distMat,self.pathindx)) #每个路径对应的距离
        return self.T0,self.pathindx,m

    #第一步：导入数据，并根据配置参数初始化网络
    def train(self):  #主函数
        [m,n] = shape(self.dataMat)
        distMat = self.distEclud(self.dataMat,self.dataMat.T) #转换为邻接矩阵（距离矩阵）
        # T为当前温度，curpath为当前路径索引，MAX_M为内循环最大迭代次数
        [T,curpath,MAX_M] = self.initBMNet(m,n,distMat)

    #进入主循环，计算最优路径
        step = 0 #初始化外循环迭代
        while step <= self.MAX_ITER:   #外循环
            m = 0                       #内循环计数器
            while m <= MAX_M:          #内循环
                curdist = self.pathLen(distMat,curpath) #计算当前路径距离
                newpath = self.changePath(curpath)      #交换产生新路径
                newdist = self.pathLen(distMat,newpath) #计算新路径距离
                #判断网络是否是一个局部稳态
                if (curdist > newdist):
                    curpath = newpath
                    self.pathindx.append(curpath)
                    self.dist.append(newdist)
                    self.iteration += 1       #增加迭代次数
                else:                         #如果网络处于局部稳定状态，则执行玻尔兹曼函数
                    if random.rand()<self.boltzmann(newdist,curdist,T):
                        curpath = newpath
                        self.pathindx.append(curpath)
                        self.dist.append(newdist)
                        self.iteration += 1   #增加迭代次数
            m += 1
            step += 1
            T = T *self.Lambda   #降温，返回迭代，直至算法终止
    #第三步：提取最优路径
        self.bestdist = min(self.dist)
        indxes = argmin(self.dist)
        self.bestdist = self.pathindx[indxes]

bmNet = BoltzmannNet()
bmNet.loadDataSet("dataSet25.txt")
bmNet.train()
print u"循环迭代",bmNet.bestdist
print  u"最佳路线",bmNet.bestpath
#显示优化后的城市地图、路径图
bmNet.drawScatter(plt)
plt.show()

bmNet.Trendline(plt) #绘制误差算法收敛曲线
plt.show()

资料来源：郑捷《机器学习算法原理与编程实践》仅供学习研究

郑捷《机器学习算法原理与编程实践》学习笔记（第四章推荐系统原理）kmeans

（上接第二章）　　4.3.1KMeans算法流程　　算法的过程如下：　　（1）从N个数据文档随机选取K个文档作为质心　　（2）对剩余的每个文档测量其到每个质心的距离，并把它归到最近的质心的类　　（3）重新计算已经得到的各... 查看详情

郑捷《机器学习算法原理与编程实践》学习笔记（第七章预测技术与哲学）7.3岭回归

7.3岭回归7.3.1验证多重共线性7.3.2岭回归理论7.3.3岭际分析7.3.4k值的判断7.3.5辅助函数（1）导入多维数据集：加载数据集defloadDataSet(filename):numFeat=len(open(filename).readline().split(‘ ‘))-1#getnumberoffieldsdataMat=[]labelMat=[]fr=ope 查看详情

郑捷《机器学习算法原理与编程实践》学习笔记（第七章预测技术与哲学）7.1线性系统的预测

7.1.1回归与现代预测 7.1.2最小二乘法 7.1.3代码实现（1）导入数据defloadDataSet(self,filename):#加载数据集X=[];Y=[]fr=open(filename)forlineinfr.readlines():curLine=line.strip().split(‘ ‘)X.append(float(curLine[0]) 查看详情

郑捷《机器学习算法原理与编程实践》学习笔记（第二章中文文本分类—朴素贝叶斯算法）

（上接第二章）　　2.3分类算法：朴素贝叶斯　　2.3.1贝叶斯公式推导（略）　　分类的流程：　　　　第一阶段：训练数据生成训练样本集：TF-IDF　　第二阶段：对每个类别计算p（yi）。　　第三个阶段：对每个特征属性计算... 查看详情

郑捷《机器学习算法原理与编程实践》学习笔记（第三章决策树的发展）_scikit-learn与回归树

　　（上接第三章）　　　3.4Scikit-Learn与回归树　　3.4.1回归算法原理　　在预测中，CART使用最小剩余方差（squaredResidualsMinimization）来判断回归时的最优划分，这个准则期望划分之后的子树与样本点的误差方差最小。这样决策... 查看详情

机器学习之逐次下降法(机器学习算法原理与实践）郑捷

逐次下降法的定义：对于给定的方程组，使用公式：其中k为迭代次数（k=0,1,2,…）逐步代入求近似解的方法称为迭代法如果存在（记为），称此迭代法收敛，显然就是方程组的解，否则称此迭代法发散。研究的收敛... 查看详情

《机器学习算法原理与编程实践》学习笔记

（上接第一章）1.2对象、矩阵与矢量化编程1.2.1对象与维度（略）1.2.2初识矩阵（略）1.2.3矢量化编程与GPU运算（略）1.2.4理解数学公式与NumPy矩阵运算1.矩阵的初始化#coding:utf-8importnumpyasnp#导入NumPy包#创建3*5的全0矩阵和全1的矩阵my... 查看详情

《机器学习算法原理与编程实践》学习笔记

（上接第一章）1.2.5Linalg线性代数库　　在矩阵的基本运算基础之上，NumPy的Linalg库可以满足大多数的线性代数运算。　　.矩阵的行列式　　.矩阵的逆　　.矩阵的对称　　.矩阵的秩　　.可逆矩阵求解线性方程1.矩阵的行列式In[4... 查看详情

机器学习算法原理与编程实践之朴素贝叶斯分类

在介绍朴素贝叶斯分类之前，首先介绍一下大家都比较了解的贝叶斯定理，即已知某条件概率，如何得到两个时间交换后的概率，也就是在已知P(A|B)的情况下如何求得P(B|A)？可以通过如下公式求得：而朴素贝叶斯分类是一种简单... 查看详情

常用机器学习算法knn原理与实践

推荐两篇讲解与实践KNN比较好博客，感谢原作者总结http://blog.csdn.net/u012162613/article/details/41768407http://www.cnblogs.com/ybjourney/p/4702562.html 查看详情

机器学习-西瓜书南瓜书第六章

支持向量机支持向量机（SupportVectorMachine），简称SVM，是一种经典的二分类模型，属于监督学习算法。一、间隔与支持向量支持向量机的目标是确定一个对样本的分类结果最鲁棒的线性分类器，即找到一个... 查看详情

深度学习笔记

...ticsinmoid）：将线性函数的输出压缩进区间(0,1)。逻辑回归机器学习算法与Python实践之（七）逻辑回归（LogisticRegression）Coursera公开课笔记:斯坦福大学机器学习第六课“逻辑回归(LogisticRegression)” 支持向量机（supportvectormachine... 查看详情

机器学习算法与编程实践之中文文本分类

这周学习了机器学习算法与编程实践第二章——中文文本分类的部分内容。该章以文本挖掘为大背景，以文本分类算法为中心，详细介绍了中文文本分类项目的相关知识点。一、文本挖掘与文本分类的概念被普遍认可的文本挖掘... 查看详情

深度学习bible学习笔记：第六章深度前馈网络

第四章数值计算（numericalcalculation）和第五章机器学习基础下去自己看。一、深度前馈网络（DeepFeedfarwardNetwork，DFN）概要：DFN：深度前馈网络，或前馈神经网络（FFN）/多层感知机（MLP）目标：近似模拟某函数f y=f(x;θ)　... 查看详情

《深度卷积神经网络原理与实践》笔记第一章机器学习基础

...记（Version：1.0.2）整理作者：sq_csl第一章机器学习基础1.1机器学习概述1.1.1概念概念ML（MachineLearning）是一门发展了比较长时间的学科，其在发展过程中定义也发生了一些变化早期概念源于TomMit 查看详情

第六章---机器学习与数据建模

学习：通过接收到的数据，归纳提取相同与不同机器学习：让计算机以数据为基础，进行归纳与总结模型：数据解释现象的系统机器学习：1.监督学习（机器学习的过程有标注：相当于告诉模型，在什么样的数据特征下应该... 查看详情

机器学习笔记_prml_adaboost算法的原理与推导

转自：http://blog.csdn.net/v_july_v/article/details/40718799 Adaboost算法的原理与推导 1Adaboost的原理1.1Adaboost是什么 AdaBoost，是英文"AdaptiveBoosting"（自适应增强）的缩写，由YoavFreund和Robert 查看详情

[java学习笔记]java核心技术卷1第六章接口与内部类

第6章接口与内部类6.1接口一个类可以实现一个或多个接口，并在需要接口的地方，随时使用实现了相应接口的对象。在接口声明中，方法自动public，可以不写修饰符。在实现接口时必须把方法声明为public。一个接口中可以包含... 查看详情