精华内容
下载资源
问答
  • LDA模型代码解析

    2018-12-20 11:04:30
    LDA模型代码解析
  • YaHoo LDA 模型代码

    2015-04-09 00:47:01
    YAHOO 对LDA模型的C++实现 LDA是一种主题模型
  • LDA模型代码分析

    千次阅读 2018-07-07 12:44:00
    笔者最近在研究机器学习相关的算法,正好学到了LDA(主题模型),所以就网上的一段主题模型的相关代码做一下分析。 以笔者的想法来看,主题模型类似于聚类,例如对一堆文档进行聚类,猜测文档有K个主题,则经过一连串...

    笔者最近在研究机器学习相关的算法,正好学到了LDA(主题模型),所以就网上的一段主题模型的相关代码做一下分析。

    以笔者的想法来看,主题模型类似于聚类,例如对一堆文档进行聚类,猜测文档有K个主题,则经过一连串的计算,将这堆文档划分为K类。话不多说,先上代码(注:本代码转载自 https://www.cnblogs.com/fujian-code/p/7637571.html,笔者额外加了一些注释,本段代码基于python3):

    #-*- coding:utf-8 -*-
    import logging
    import logging.config
    import configparser
    import numpy as np
    import random
    import codecs
    import os
     
    from collections import OrderedDict
    #获取当前路径
    path = os.getcwd()
    #导入日志配置文件
    logging.config.fileConfig("logging.conf")
    #创建日志对象
    logger = logging.getLogger()
    # loggerInfo = logging.getLogger("TimeInfoLogger")
    # Consolelogger = logging.getLogger("ConsoleLogger")
     
    #导入配置文件
    conf = configparser.ConfigParser()
    conf.read("setting.conf") 
    #文件路径
    trainfile = os.path.join(path,os.path.normpath(conf.get("filepath", "trainfile")))
    wordidmapfile = os.path.join(path,os.path.normpath(conf.get("filepath","wordidmapfile")))
    thetafile = os.path.join(path,os.path.normpath(conf.get("filepath","thetafile")))
    phifile = os.path.join(path,os.path.normpath(conf.get("filepath","phifile")))
    paramfile = os.path.join(path,os.path.normpath(conf.get("filepath","paramfile")))
    topNfile = os.path.join(path,os.path.normpath(conf.get("filepath","topNfile")))
    tassginfile = os.path.join(path,os.path.normpath(conf.get("filepath","tassginfile")))
    #模型初始参数
    K = int(conf.get("model_args","K"))
    alpha = float(conf.get("model_args","alpha"))
    beta = float(conf.get("model_args","beta"))
    iter_times = int(conf.get("model_args","iter_times"))
    top_words_num = int(conf.get("model_args","top_words_num"))
    class Document(object):
        def __init__(self):
            self.words = []
            self.length = 0
    #把整个文档及真的单词构成vocabulary(不允许重复)
    class DataPreProcessing(object):
        def __init__(self):
            self.docs_count = 0
            self.words_count = 0
            #保存每个文档d的信息(单词序列,以及length)
            self.docs = []
            #建立vocabulary表,照片文档的单词
            self.word2id = OrderedDict()
        def cachewordidmap(self):
            with codecs.open(wordidmapfile, 'w','utf-8') as f:
                for word,id in self.word2id.items():
                    f.write(word +"\t"+str(id)+"\n")
    class LDAModel(object):
        def __init__(self,dpre):
            self.dpre = dpre #获取预处理参数
            #
            #模型参数
            #聚类个数K,迭代次数iter_times,每个类特征词个数top_words_num,超参数α(alpha) β(beta)
            #
            self.K = K
            self.beta = beta
            self.alpha = alpha
            self.iter_times = iter_times
            self.top_words_num = top_words_num 
            #
            #文件变量
            #分好词的文件trainfile
            #词对应id文件wordidmapfile
            #文章-主题分布文件thetafile
            #词-主题分布文件phifile
            #每个主题topN词文件topNfile
            #最后分派结果文件tassginfile
            #模型训练选择的参数文件paramfile
            #
            self.wordidmapfile = wordidmapfile
            self.trainfile = trainfile
            self.thetafile = thetafile
            self.phifile = phifile
            self.topNfile = topNfile
            self.tassginfile = tassginfile
            self.paramfile = paramfile
            # p,概率向量 double类型,存储采样的临时变量
            # nw,词word在主题topic上的分布
            # nwsum,每各topic的词的总数
            # nd,每个doc中各个topic的词的总数
            # ndsum,每各doc中词的总数
            self.p = np.zeros(self.K)
            # nw,词word在主题topic上的分布
            self.nw = np.zeros((self.dpre.words_count,self.K),dtype="int")
            # nwsum,每各topic的词的总数
            self.nwsum = np.zeros(self.K,dtype="int")
            # nd,每个doc中各个topic的词的总数
            self.nd = np.zeros((self.dpre.docs_count,self.K),dtype="int")
            # ndsum,每个doc中词的总数
            self.ndsum = np.zeros(dpre.docs_count,dtype="int")
    		# 1000个文档  *  假设第一个文档 1024个词汇  第二个文档 1133个词汇 第三个文档 1458个词汇
            self.Z = np.array([ [0 for y in range(dpre.docs[x].length)] for x in range(dpre.docs_count)])        # M*doc.size(),文档中词的主题分布
     
            #随机先分配类型,为每个文档中的各个单词分配主题
            for x in range(len(self.Z)):
                self.ndsum[x] = self.dpre.docs[x].length
                for y in range(self.dpre.docs[x].length):
                    topic = random.randint(0,self.K-1)#随机取一个主题
                    self.Z[x][y] = topic#文档中词的主题分布
                    self.nw[self.dpre.docs[x].words[y]][topic] += 1
    				#self.nd['文档一']['娱乐']
                    self.nd[x][topic] += 1
    				#topic['新闻'] 最后假设有5123个词
                    self.nwsum[topic] += 1
     
    		#theta 代表  1000个文档 * 10个topic  都是0.0
            self.theta = np.array([ [0.0 for y in range(self.K)] for x in range(self.dpre.docs_count) ])
            #phi  代表   10个主题 * 100000个单词
            self.phi = np.array([ [ 0.0 for y in range(self.dpre.words_count) ] for x in range(self.K)]) 
        def sampling(self,i,j):
            #换主题  第i个文档 第j个词汇 所属的topic
            topic = self.Z[i][j]
            #只是单词的编号,都是从0开始word就是等于j
            word = self.dpre.docs[i].words[j]
            #if word==j:
            #    print 'true'
            self.nw[word][topic] -= 1
            self.nd[i][topic] -= 1
            self.nwsum[topic] -= 1
            self.ndsum[i] -= 1
     
            Vbeta = self.dpre.words_count * self.beta
            Kalpha = self.K * self.alpha
    		
    		# 1000个文档 10个主题, 总共300000个词汇
    		# nw  300000 * 10
    		# nwsum 1 * 10      [30000,30000,30000,30000,30000,30000,30000,30000,30000,30000] 代表每个主题 30000个词汇
    		# nd  1000 * 10     第i个文档,第j个主题下,共有多少单词
    		# ndsum  1 * 1000   [300,300,300,.......] 总共有1000个300 每个文档平均300个词汇
            self.p = (self.nw[word] + self.beta)/(self.nwsum + Vbeta) * \
                     (self.nd[i] + self.alpha) / (self.ndsum[i] + Kalpha)
     
            #随机更新主题的吗
            # for k in range(1,self.K):
            #     self.p[k] += self.p[k-1]
            # u = random.uniform(0,self.p[self.K-1])
            # for topic in range(self.K):
            #     if self.p[topic]>u:
            #         break
     
            #按这个更新主题更好理解,这个效果还不错
            p = np.squeeze(np.asarray(self.p/np.sum(self.p)))
            topic = np.argmax(np.random.multinomial(1, p))
     
            self.nw[word][topic] +=1
            self.nwsum[topic] +=1
            self.nd[i][topic] +=1
            self.ndsum[i] +=1
            return topic
        def est(self):
            # Consolelogger.info(u"迭代次数为%s 次" % self.iter_times)
            for x in range(self.iter_times):
                for i in range(self.dpre.docs_count):
                    for j in range(self.dpre.docs[i].length):
                        topic = self.sampling(i,j)
                        self.Z[i][j] = topic
            logger.info(u"迭代完成。")
            logger.debug(u"计算文章-主题分布")
            self._theta()
            logger.debug(u"计算词-主题分布")
            self._phi()
            logger.debug(u"保存模型")
            self.save()
        def _theta(self):
            for i in range(self.dpre.docs_count):#遍历文档的个数词
                self.theta[i] = (self.nd[i]+self.alpha)/(self.ndsum[i]+self.K * self.alpha)
        def _phi(self):
            for i in range(self.K):
                self.phi[i] = (self.nw.T[i] + self.beta)/(self.nwsum[i]+self.dpre.words_count * self.beta)
        def save(self):
            # 保存theta文章-主题分布
            logger.info(u"文章-主题分布已保存到%s" % self.thetafile)
            with codecs.open(self.thetafile,'w') as f:
                for x in range(self.dpre.docs_count):
                    for y in range(self.K):
                        f.write(str(self.theta[x][y]) + '\t')
                    f.write('\n')
            # 保存phi词-主题分布
            logger.info(u"词-主题分布已保存到%s" % self.phifile)
            with codecs.open(self.phifile,'w') as f:
                for x in range(self.K):
                    for y in range(self.dpre.words_count):
                        f.write(str(self.phi[x][y]) + '\t')
                    f.write('\n')
            # 保存参数设置
            logger.info(u"参数设置已保存到%s" % self.paramfile)
            with codecs.open(self.paramfile,'w','utf-8') as f:
                f.write('K=' + str(self.K) + '\n')
                f.write('alpha=' + str(self.alpha) + '\n')
                f.write('beta=' + str(self.beta) + '\n')
                f.write(u'迭代次数  iter_times=' + str(self.iter_times) + '\n')
                f.write(u'每个类的高频词显示个数  top_words_num=' + str(self.top_words_num) + '\n')
            # 保存每个主题topic的词
            logger.info(u"主题topN词已保存到%s" % self.topNfile)
     
            with codecs.open(self.topNfile,'w','utf-8') as f:
                self.top_words_num = min(self.top_words_num,self.dpre.words_count)
                for x in range(self.K):
                    f.write(u'第' + str(x) + u'类:' + '\n')
                    twords = []
                    twords = [(n,self.phi[x][n]) for n in range(self.dpre.words_count)]
                    twords.sort(key = lambda i:i[1], reverse= True)
                    for y in range(self.top_words_num):
                        word = OrderedDict({value:key for key, value in self.dpre.word2id.items()})[twords[y][0]]
                        f.write('\t'*2+ word +'\t' + str(twords[y][1])+ '\n')
            # 保存最后退出时,文章的词分派的主题的结果
            logger.info(u"文章-词-主题分派结果已保存到%s" % self.tassginfile)
            with codecs.open(self.tassginfile,'w') as f:
                for x in range(self.dpre.docs_count):
                    for y in range(self.dpre.docs[x].length):
                        f.write(str(self.dpre.docs[x].words[y])+':'+str(self.Z[x][y])+ '\t')
                    f.write('\n')
            logger.info(u"模型训练完成。")
    # 数据预处理,即:生成d()单词序列,以及词汇表
    def preprocessing():
        logger.info(u'载入数据......')
        with codecs.open(trainfile, 'r','utf-8') as f:
            docs = f.readlines()
        logger.debug(u"载入完成,准备生成字典对象和统计文本数据...")
        # 大的文档集
        dpre = DataPreProcessing()
        items_idx = 0
        for line in docs:
            if line != "":
                tmp = line.strip().split()
                # 生成一个文档对象:包含单词序列(w1,w2,w3,,,,,wn)可以重复的
                doc = Document()
                for item in tmp:
                    if item in dpre.word2id:# 已有的话,只是当前文档追加
                        doc.words.append(dpre.word2id[item])
                    else:  # 没有的话,要更新vocabulary中的单词词典及wordidmap
                        dpre.word2id[item] = items_idx
                        doc.words.append(items_idx)
                        items_idx += 1
                doc.length = len(tmp)
                dpre.docs.append(doc)
            else:
                pass
        dpre.docs_count = len(dpre.docs) # 文档数
        dpre.words_count = len(dpre.word2id) # 词汇数
        logger.info(u"共有%s个文档" % dpre.docs_count)
        dpre.cachewordidmap()
        logger.info(u"词与序号对应关系已保存到%s" % wordidmapfile)
        return dpre
    def run():
        # 处理文档集,及计算文档数,以及vocabulary词的总个数,以及每个文档的单词序列
        dpre = preprocessing()
        lda = LDAModel(dpre)
        lda.est()
    if __name__ == '__main__':
        run()                           
    假设有1000个文档,总共300000万个词汇,平均每个文档300个词汇
    代码的逻辑大致为:
        1. 从当前文件夹下加载配置文件setting.conf,
        2. 读取训练集文件trainfile,trainfile包括1000行,每行代表1个文档,且做好分词,笔者的训练文档并没有像笔者说的那样每个 文档300个词汇,300个词汇只是做个假设,方便分析而已
        3. 初始化文档的相关信息,计算文档数目(docs_count),词汇数目(words_count),词汇和序号对应字典表(word2id),以及单独的序号list(words)
        4. 初始化参数,各个参数含义如下:
            K:主题个数
            alpha:平滑参数,防止有些主题下,单词数目为0,则计算出来的概率为0
            beta:平滑参数,防止有文档没有单词,则计算出来的概率为0
            iter_times:训练数据时的循环次数上限
            top_words_num:最后要展示的每个类的高频词个数
            其它不同文件的作用,已在代码中说明
        5. 初始化相关矩阵,各个矩阵大致含义如下:
            p:1行10列的矩阵(因为假设有10个主题),概率向量 double类型,存储采样的临时变量
            nw:300000行10列的矩阵(因为假设有300000个单词),词word在主题topic上的分布,假设nw[0][0]=3,代表第一个词,在第一个主题下有出现了3次
            nwsum:1行10列的矩阵,每个主题的词的总数
            nd:1000行10列的矩阵,每个文档对应主题下的词的数目
            ndsum:1行1000列的矩阵,每个文档的词数
            Z:1000行,每行的列数不固定,因为实际情况下,每个文档长短不一,1000个词对应1000个列
            theta:1000行10列的矩阵,代表每个文档属于某个主题的概率
            phi:10行300000列的矩阵,代表某个词属于某个主题的概率
    
    
        6. 循环1000个文档,并循环每个文档的单词,初始时,为每个文档随机分配一个主题,并统计各个矩阵
        7. 然后对文档进行采样,计算每个文档中的每个词所属的主题
            采样的过程如下:
                for iter_times:参数里面设置的循环次数
                    for docs:  循环每个文档
                        for word:循环每个具体文档的词
                            topic = sampling(i,j)  第i个文档的第j个单词,从新计算其所属主题
                            Z[i][j] = topic        将主题赋给相应的矩阵元素
                其中sampling的步骤如下:
                    a.先取得(i,j)对应的单词的主题,将该主题对应的统计频次,各自减1,
                    b.计算中间平滑参数,Vbeta和Kalpha,这里的Vbeta和Kalpha笔者并不是特别了解
                    c.进行新的概率的计算,根据这个概率按照多项式分布计算出一个新的主题
                    d.将这个新的主题的统计频次各加1
                    e.返回该主题
    		其中c步骤的公式,笔者大致理解如下图所示: 


    LDA主题模型代码的讲解大致就这样,笔者首次发博客,有很多不懂的,还请各位多多指教

    展开全文
  • LDA主题模型代码

    2017-04-24 21:19:48
    LDA主题模型代码
  • r语言做灰色预测模型代码为什么会出错?我正在MATLAB下编写一个Grey system的函数库, 我想其他的网友也做过类似的工作吧. 灰色模型的MATLAB求解代码应该很容易找到吧.如果不想用MATLAB你也可以用Cpython lda主题...

    r语言做灰色预测模型代码为什么会出错?

    我正在MATLAB下编写一个Grey system的函数库, 我想其他的网友也做过类似的工作吧. 灰色模型的MATLAB求解代码应该很容易找到吧.如果不想用MATLAB你也可以用C

    python lda主题模型,需要使用什么包?

    python lda 主题模型 需要使用什么包 数据结构是程序构成的重要部分,链表、树、图这些在用C 编程时需要仔细表达的问题在Python 中简单了很多。在Python 中,最基本的数据结构就是数组、序列和哈希表,用它们想要表达各种常见的数据结构是非常容易的。没了定义指针、分配内存的任务,编程变得有趣了。CORBA 是一种高级的软件体系结构,它是语言无关平台无关的。C 、Java 等语言都有CORBA 绑定,但与它们相比,Python 的 CORBA 绑定却容易很多,因为在程序员看来,一个 CORBA 的类和 Python 的类用起来以及实现起来并没有什么差别。

    R语言最优化模型怎么做?

    参考代码: dat&lt-read.table("clipboard",header=T) dat lm.d&lt-lm(y~x1 x2 x3 x4 x5,data=dat) summary(lm.d) lm.d2&lt-step(lm.d)#逐步回归法,挑选变量子集 summary(lm.d2) newd&lt-data.frame(x1=12135,x2=28679,x3=19978,x4=502,x5=24950) predict(lm.d,newd,interval="prediction")#预测值 predict(lm.d,newd,interval="prediction",scale=T)#预测均值

    R语言对数学建模有没有帮助?

    一般与统计学相关的建模,R语言就肯定有人用。例如时间序列arima,多元时间序列VAR,VEC,ETS,ESM等等。因为R是统计学家设计的开源代码。另外机器学习的模型也有,例如SVM,随机森林,神经网络,R都可以做一些。当然,简单的线性规划,R也可以做。

    除了JGibbLDA,还有没有其他的LDA主题模型的开源实现?

    用过。挺简单的。如果仅是单纯调用的话, 主要就是输入文件要自己生成, 另外要确定下主题数目

    sparkmlliblda主题模型一般迭代多少次?

    LDA主题模型的评价指标是困惑度,困惑度越小,模型越好。所以,可以跑一组实验,看不同迭代次数对应的困惑度是多少,画一条曲线,最小困惑度对应的迭代次数即为最佳次数。迭代次数太少,会导致模型尚未收敛,迭代次数太多,又会浪费计算资源。

    展开全文
  • LDA主题代码+读取文档代码+分词代码,都是JAVA实现的,运行流畅方便
  • 基于sklearn的线性判别分析(LDA)代码实现一、前言及回顾本文记录使用sklearn库实现有监督的数据降维技术——线性判别分析(LDA)。在上一篇LDA线性判别分析原理及python应用(葡萄酒案例分析),我们通过详细的步骤理解...

    基于sklearn的线性判别分析(LDA)代码实现

    一、前言及回顾

    本文记录使用sklearn库实现有监督的数据降维技术——线性判别分析(LDA)。在上一篇LDA线性判别分析原理及python应用(葡萄酒案例分析),我们通过详细的步骤理解LDA内部逻辑实现原理,能够更好地掌握线性判别分析的内部机制。当然,在以后项目数据处理,我们有更高效的实现方法,这篇将记录学习基于sklearn进行LDA数据降维,提高编码速度,而且会感觉更加简单。

    学习之后可以对数据降维处理两种实现方法进行对比:

    二、定义分类结果可视化函数

    这个函数与上一篇文章 运用sklearn进行主成分分析(PCA)代码实现 里是一样的,plot_decision_region函数在分类结果区别决策区域中可以复用。

    def plot_decision_regions(x, y, classifier, resolution=0.02):

    markers = ['s', 'x', 'o', '^', 'v']

    colors = ['r', 'g', 'b', 'gray', 'cyan']

    cmap = ListedColormap(colors[:len(np.unique(y))])

    x1_min, x1_max = x[:, 0].min() - 1, x[:, 0].max() + 1

    x2_min, x2_max = x[:, 1].min() - 1, x[:, 1].max() + 1

    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution), np.arange(x2_min, x2_max, resolution))

    z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)

    z = z.reshape(xx1.shape)

    plt.contourf(xx1, xx2, z, alpha=0.4, cmap=cmap)

    for idx, cc in enumerate(np.unique(y)):

    plt.scatter(x=x[y == cc, 0],

    y=x[y == cc, 1],

    alpha=0.6,

    c=cmap(idx),

    edgecolor='black',

    marker=markers[idx],

    label=cc)

    三、10行代码实现葡萄酒数据集分类

    sklearn依然实现了LDA类方法,我们只需要直接调用而无需自己实现内部逻辑,这样显得更加方便。所以,10行代码实现也不为过,重点需要先理解内部逻辑原理。

    关键代码如下:

    lda = LDA(n_components=2)

    lr = LogisticRegression()

    x_train_lda = lda.fit_transform(x_train_std, y_train) # LDA是有监督方法,需要用到标签

    x_test_lda = lda.fit_transform(x_test_std, y_test) # 预测时候特征向量正负问题,乘-1反转镜像

    lr.fit(x_train_lda, y_train)

    plot_decision_regions(x_train_pca, y_train, classifier=lr)

    plt.xlabel('LD1')

    plt.ylabel('LD2')

    plt.legend(loc='lower left')

    plt.show()

    使用训练集拟合模型之后,分类效果如何呢?

    可以看到模型对训练数据集精确地分类,比PCA效果好,因为LDA使用了数据集的标签,是有监督的学习。

    更准确来说,我们要看模型在测试集上的效果,对比如下:

    可见,经过逻辑回归分类器,提取了两个最具线性判别性的特征,将包含13个特征的葡萄酒数据集投影到二维子空间,实现了精确地分类。

    四、完整代码

    from sklearn.linear_model import LogisticRegression

    from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA

    from sklearn.preprocessing import StandardScaler

    from sklearn.model_selection import train_test_split

    from matplotlib.colors import ListedColormap

    import matplotlib.pyplot as plt

    import pandas as pd

    import numpy as np

    def plot_decision_regions(x, y, classifier, resolution=0.02):

    markers = ['s', 'x', 'o', '^', 'v']

    colors = ['r', 'g', 'b', 'gray', 'cyan']

    cmap = ListedColormap(colors[:len(np.unique(y))])

    x1_min, x1_max = x[:, 0].min() - 1, x[:, 0].max() + 1

    x2_min, x2_max = x[:, 1].min() - 1, x[:, 1].max() + 1

    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution), np.arange(x2_min, x2_max, resolution))

    z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)

    z = z.reshape(xx1.shape)

    plt.contourf(xx1, xx2, z, alpha=0.4, cmap=cmap)

    for idx, cc in enumerate(np.unique(y)):

    plt.scatter(x=x[y == cc, 0],

    y=x[y == cc, 1],

    alpha=0.6,

    c=cmap(idx),

    edgecolor='black',

    marker=markers[idx],

    label=cc)

    def main():

    # load data

    df_wine = pd.read_csv('D:\\PyCharm_Project\\maching_learning\\wine_data\\wine.data', header=None) # 本地加载

    # df_wine = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data',

    # header=None) # 服务器加载

    # split the data,train:test=7:3

    x, y = df_wine.iloc[:, 1:].values, df_wine.iloc[:, 0].values

    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, stratify=y, random_state=0)

    # standardize the feature 标准化单位方差

    sc = StandardScaler()

    x_train_std = sc.fit_transform(x_train)

    x_test_std = sc.fit_transform(x_test)

    lda = LDA(n_components=2)

    lr = LogisticRegression()

    x_train_lda = lda.fit_transform(x_train_std, y_train) # LDA是有监督方法,需要用到标签

    x_test_lda = lda.fit_transform(x_test_std, y_test) # 预测时候特征向量正负问题,乘-1反转镜像

    lr.fit(x_train_lda, y_train)

    plt.figure(figsize=(6, 7), dpi=100) # 画图高宽,像素

    plt.subplot(2, 1, 1)

    plot_decision_regions(x_train_lda, y_train, classifier=lr)

    plt.title('Training Result')

    plt.xlabel('LD1')

    plt.ylabel('LD2')

    plt.legend(loc='lower left')

    plt.subplot(2, 1, 2)

    plot_decision_regions(x_test_lda, y_test, classifier=lr)

    plt.title('Testing Result')

    plt.xlabel('LD1')

    plt.ylabel('LD2')

    plt.legend(loc='lower left')

    plt.tight_layout() # 子图间距

    plt.show()

    if __name__ == '__main__':

    main()

    五、降维压缩数据技术总结

    至此,数据降维压缩的技术学习告一段落,经过这次学习,我感觉到一次比较系统的学习会收获更多,此次学习了主成分分析(PCA)和线性判别分析(LDA),这两种经典的数据降维技术各有特点。

    前者是无监督技术,忽略分类标签,寻找最大化方差方向提取主成分;后者是有监督技术,训练时候考虑分类标签,在线性特征空间最大化类的可分性。应用场景也各有优势,PCA在图像识别应用好,LDA在特征提取方面更有优势。

    这里列出这次学习过程的博文记录,方便查找:

    版权声明:本文为博主原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接和本声明。

    机器学习 —— 基础整理(四)特征提取之线性方法:主成分分析PCA、独立成分分析ICA、线性判别分析LDA

    本文简单整理了以下内容: (一)维数灾难 (二)特征提取--线性方法 1. 主成分分析PCA 2. 独立成分分析ICA 3. 线性判别分析LDA (一)维数灾难(Curse of dimensiona ...

    机器学习理论基础学习3.2--- Linear classification 线性分类之线性判别分析(LDA)

    在学习LDA之前,有必要将其自然语言处理领域的LDA区别开来,在自然语言处理领域, LDA是隐含狄利克雷分布(Latent Dirichlet Allocation,简称LDA),是一种处理文档的主题 ...

    线性判别分析LDA原理总结

    在主成分分析(PCA)原理总结中,我们对降维算法PCA做了总结.这里我们就对另外一种经典的降维方法线性判别分析(Linear Discriminant Analysis, 以下简称LDA)做一个总结. ...

    线性判别分析LDA详解

    1 Linear Discriminant Analysis    相较于FLD(Fisher Linear Decriminant),LDA假设:1.样本数据服从正态分布,2.各类得协方差相等.虽然 ...

    线性判别分析 LDA

    点到判决面的距离 点\(x_0\)到决策面\(g(x)= w^Tx+w_0\)的距离:\(r={g(x)\over \|w\|}\) 广义线性判别函数 因任何非线性函数都可以通过级数展开转化为多项式函 ...

    机器学习中的数学-线性判别分析(LDA)

    前言在之前的一篇博客机器学习中的数学(7)——PCA的数学原理中深入讲解了,PCA的数学原理.谈到PCA就不得不谈LDA,他们就像是一对孪生兄弟,总是被人们放在一起学习,比较.这这篇博客中我们就来谈谈 ...

    主成分分析(PCA)与线性判别分析(LDA)

    主成分分析 线性.非监督.全局的降维算法 PCA最大方差理论 出发点:在信号处理领域,信号具有较大方差,噪声具有较小方差 目标:最大化投影方差,让数据在主投影方向上方差最大 PCA的求解方法: 对样本 ...

    LDA线性判别分析原理及python应用(葡萄酒案例分析)

    目录 线性判别分析(LDA)数据降维及案例实战 一.LDA是什么 二.计算散布矩阵 三.线性判别式及特征选择 四.样本数据降维投影 五.完整代码 结语 一.LDA是什么 LDA概念及与PCA区别 LD ...

    线性判别分析(LDA)准则:FIsher准则、感知机准则、最小二乘(最小均方误差)准则

    准则 采用一种分类形式后,就要采用准则来衡量分类的效果,最好的结果一般出现在准则函数的极值点上,因此将分类器的设计问题转化为求准则函数极值问题,即求准则函数的参数,如线性分类器中的权值向量. 分类器设 ...

    随机推荐

    R平方

    参考其他网页 通常R2越大越好,但看到亦在后面标上P值,这两者之间有何联系? R2和p值没有必然联系.就像你做线性分析和(单因素或多因素)方差分析一样,若A和K线性相关,也有可能A对K么有显著性影响一 ...

    【转】mysql安装图解

    转载地址:http://www.jb51.net/article/23876.htm 很多朋友刚开始接触mysql数据库服务器,下面是网友整理的一篇mysql的安装教程,步骤明细也有详细的说明.   ...

    PHP导出数据库数据字典脚本

    MD中bitmap源代码分析--状态机实例

    1. page_attrs的状态转换关系 之前说过,bitmap的优化核心是:bitmap设置后批量写入:bitmap延时清除.写bit用bitmap_statrwrite() + bitmap_un ...

    jmeter 通过ant集成到jenkins

    jmeter可以通过ant自动执行测试脚本,然后集成到jenkins上,并发送测试报告 1.下载安装ant 2.将jmeter安装包extras文件夹里ant-jemter-1.1.1.jar 复制到 ...

    Java面试题之Java基础

    1. JDK 和 JRE 有什么区别? JRE(JavaRuntimeEnvironment,Java运行环境),也就是Java平台.所有的Java 程序都要在JRE下才能运行.普通用户只需要运行已开 ...

    cs架构与bs架构的对比

    主要区别: Client/Server是建立在局域网的基础上的.Browser/Server是建立在广域网的基础上的. 1.硬件环境不同 C/S 一般建立在专用的网络上, 小范围里的网络环境, 局域网 ...

    阿里巴巴Web前端面试的一道JS题目,求解答!!!

    题目大概是这种: function outer(){ return inner; var inner = "a"; function inner(){}; inner = 9; } ...

    喵哈哈村的魔法考试 Round #13 (Div.2) 题解

    喵哈哈村的木星传说(一) 旋转90°,找找规律就知道(x,y)->(n-1-y,x) 然后输出就好了. #include using namespace ...

    Lua协程-测试3

    print("Lua 协程测试3") -- 实现消费者-生产者关系(生产一个就消费一个) count = -- 生产总数 -- 生产者 local newProductorCo = ...

    展开全文
  • LDA模型学习(代码

    2019-01-21 13:00:12
    LDA模型学习(代码
                   

     为了把LDA算法用于文本聚类,我真的是绞尽脑汁。除了去看让我头大的概率论、随机过程、高数这些基础的数学知识,还到网上找已经实现的源代码。

         最先让我看到署光的是Mallet,我研究了大概一个星期,最后决定放弃了。因为Mallet作者提供的例子实在太少了。

          回到了网上找到的这样一段源代码:

    1. /*  
    2.  * (C) Copyright 2005, Gregor Heinrich (gregor :: arbylon : net) (This file is  
    3.  * part of the org.knowceans experimental software packages.)  
    4.  */ 
    5. /*  
    6.  * LdaGibbsSampler is free software; you can redistribute it and/or modify it  
    7.  * under the terms of the GNU General Public License as published by the Free  
    8.  * Software Foundation; either version 2 of the License, or (at your option) any  
    9.  * later version.  
    10.  */ 
    11. /*  
    12.  * LdaGibbsSampler is distributed in the hope that it will be useful, but  
    13.  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or  
    14.  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more  
    15.  * details.  
    16.  */ 
    17. /*  
    18.  * You should have received a copy of the GNU General Public License along with  
    19.  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple  
    20.  * Place, Suite 330, Boston, MA 02111-1307 USA  
    21.  */ 
    22.  
    23. /*  
    24.  * Created on Mar 6, 2005  
    25.  */ 
    26. package com.xh.lda;  
    27.  
    28. import java.text.DecimalFormat;  
    29. import java.text.NumberFormat;  
    30.  
    31. /**  
    32.  * Gibbs sampler for estimating the best assignments of topics for words and  
    33.  * documents in a corpus. The algorithm is introduced in Tom Griffiths' paper  
    34.  * "Gibbs sampling in the generative model of Latent Dirichlet Allocation"  
    35.  * (2002).  
    36.  *   
    37.  * @author heinrich  
    38.  */ 
    39. public class LdaGibbsSampler {  
    40.  
    41.     /**  
    42.      * document data (term lists)  
    43.      */ 
    44.     int[][] documents;  
    45.  
    46.     /**  
    47.      * vocabulary size  
    48.      */ 
    49.     int V;  
    50.  
    51.     /**  
    52.      * number of topics  
    53.      */ 
    54.     int K;  
    55.  
    56.     /**  
    57.      * Dirichlet parameter (document--topic associations)  
    58.      */ 
    59.     double alpha;  
    60.  
    61.     /**  
    62.      * Dirichlet parameter (topic--term associations)  
    63.      */ 
    64.     double beta;  
    65.  
    66.     /**  
    67.      * topic assignments for each word.  
    68.      */ 
    69.     int z[][];  
    70.  
    71.     /**  
    72.      * cwt[i][j] number of instances of word i (term?) assigned to topic j.  
    73.      */ 
    74.     int[][] nw;  
    75.  
    76.     /**  
    77.      * na[i][j] number of words in document i assigned to topic j.  
    78.      */ 
    79.     int[][] nd;  
    80.  
    81.     /**  
    82.      * nwsum[j] total number of words assigned to topic j.  
    83.      */ 
    84.     int[] nwsum;  
    85.  
    86.     /**  
    87.      * nasum[i] total number of words in document i.  
    88.      */ 
    89.     int[] ndsum;  
    90.  
    91.     /**  
    92.      * cumulative statistics of theta  
    93.      */ 
    94.     double[][] thetasum;  
    95.  
    96.     /**  
    97.      * cumulative statistics of phi  
    98.      */ 
    99.     double[][] phisum;  
    100.  
    101.     /**  
    102.      * size of statistics  
    103.      */ 
    104.     int numstats;  
    105.  
    106.     /**  
    107.      * sampling lag (?)  
    108.      */ 
    109.     private static int THIN_INTERVAL = 20;  
    110.  
    111.     /**  
    112.      * burn-in period  
    113.      */ 
    114.     private static int BURN_IN = 100;  
    115.  
    116.     /**  
    117.      * max iterations  
    118.      */ 
    119.     private static int ITERATIONS = 1000;  
    120.  
    121.     /**  
    122.      * sample lag (if -1 only one sample taken)  
    123.      */ 
    124.     private static int SAMPLE_LAG;  
    125.  
    126.     private static int dispcol = 0;  
    127.  
    128.     /**  
    129.      * Initialise the Gibbs sampler with data.  
    130.      *   
    131.      * @param V  
    132.      *            vocabulary size  
    133.      * @param data  
    134.      */ 
    135.     public LdaGibbsSampler(int[][] documents, int V) {  
    136.  
    137.         this.documents = documents;  
    138.         this.V = V;  
    139.     }  
    140.  
    141.     /**  
    142.      * Initialisation: Must start with an assignment of observations to topics ?  
    143.      * Many alternatives are possible, I chose to perform random assignments  
    144.      * with equal probabilities  
    145.      *   
    146.      * @param K  
    147.      *            number of topics  
    148.      * @return z assignment of topics to words  
    149.      */ 
    150.     public void initialState(int K) {  
    151.         int i;  
    152.  
    153.         int M = documents.length;  
    154.  
    155.         // initialise count variables.  
    156.         nw = new int[V][K];  
    157.         nd = new int[M][K];  
    158.         nwsum = new int[K];  
    159.         ndsum = new int[M];  
    160.  
    161.         // The z_i are are initialised to values in [1,K] to determine the  
    162.         // initial state of the Markov chain.  
    163.  
    164.         z = new int[M][];  
    165.         for (int m = 0; m < M; m++) {  
    166.             int N = documents[m].length;  
    167.             z[m] = new int[N];  
    168.             for (int n = 
    展开全文
  • LDA主题模型代码实现流程

    千次阅读 2017-09-04 17:20:20
    LDA主题模型的原理,推导...本文主要是通过阅读别人实现的LAD主题模型代码,总结的一个实现流程,供别人想实现LAD时可作参考,如若有何错误,麻烦请指出: LDA代码流程: (1) 先对文档切词,然后对每个词语赋ID编号0~(n-...
  • LDA主题模型代码实践

    千次阅读 2019-07-30 16:19:46
    with open('LDA-data/stop_words.txt','r', encoding='gbk') as f: content = f.read() stop_list = set(content.splitlines()) stop_list.add(' ') # 单独增加空格符,没办法表示在txt文档中 # 读取数据 df = pd...
  • LDA应用
  • 几个问题: 1、停用次应该去到什么程度?? 2、比如我选了参数topicNumber=100,结果中,其中有80个topic,每个的前几个words...3、LDA考虑了多少文件之间的关系? 4、参数 alpha,beta怎么取?? alpha=K/50 ?...
  • LDA模型训练

    2020-12-09 15:52:33
    问一下LDA模型是用什么工具训练的,因为想做领域关键词的挖掘,需要针对领域训练一个新的LDA模型</p><p>该提问来源于开源项目:dongrixinyu/chinese_keyphrase_extractor</p></div>
  • 原文:https://blog.csdn.net/selinda001/article/details/80446766原文代码需要一点点调整才能跑通from nltk.stem.wordnet import WordNetLemmatizerimport stringimport pandas as pdimport gensimfrom gensim ...
  • lda算法代码

    2019-01-31 18:51:57
    lda算法模型,里面有注释,需要的同学可以拿来学习,高深的大咖就不用看了,适合初者
  • 基于spark mllib的LDA模型训练Scala代码实现

    千次阅读 热门讨论 2016-04-08 17:37:05
    从事NLP算法工作也快一年了,主要时间花在了LDA上面,但是却一直没有好好整理一下,决心把到目前为止做的一些东西分享出来,如有疑问敬请指正。 在Github上建了一个自己的项目:CkoocNLP(去这个名字是想做一个NLP...
  • 关于Latent Dirichlet Allocation及Hierarchical LDA模型的必读文章和相关代码 LDA和HLDA: (1)D. M. Blei, et al., "Latent Dirichlet allocation," Journal o...
  • LDA代码流程: (1) 先对文档切词,然后对每个词语赋ID编号0~(n-1),计算共有n个词,m个文档 (2) 参数,变量设置: K 主题数 beta β alpha α iter_times 迭代次数 top_words_num 每个主题特征词个数 p,概率向量...
  • LDA主题模型的java代码实现

    千次阅读 热门讨论 2015-08-20 10:21:30
    LDA主题模型的java代码实现,包括训练和预测
  • 文件名称: lda-java-src下载 收藏√ [5 4 3 2 1]开发工具: Java文件大小: 87 KB上传时间: 2013-08-04下载次数: 121提 供 者: 成曦详细说明:lda主题模型代码,希望对文档主题分析感兴趣的人有所帮助-lda topic model...
  • lda模型的python实现

    千次阅读 2016-03-08 17:39:11
    LDA(Latent Dirichlet Allocation)是一种文档主题生成模型,最近看了点资料,准备使用python实现一下。至于数学模型相关知识,某度一大堆,这里也给出之前参考过的一...lda模型变量申请及初始化 # #伪代码 # 输
  • 文章目录1.LDA模型构造概述:2.提炼训练文本3.对文本通过停用词表后进行分词4.训练LDA模型5.对模型进行评价6.其他操作将停用词表打包为pkl格式通过LDA模型得到每条文本所属的类别 1.LDA模型构造概述: 整体上来说...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 272
精华内容 108
关键字:

lda模型代码