精华内容
下载资源
问答
  • 结合复杂多样的实际数据环境,探讨数据挖掘的使用场景和使用方法 《数据挖掘原理与实践》理论联系实际,讲述数据...基础章节:数据挖掘主要有四个“超级问题”,即聚类、分类、关联模式挖掘和异常分析,它们的重要性

    结合复杂多样的实际数据环境,探讨数据挖掘的使用场景和使用方法

    《数据挖掘:原理与实践》理论联系实际,讲述数据挖据理论、技术及应用的教材。研讨了数据挖掘的方方面面,从基础理论到复杂数据类型及其应用。不仅讨论传统的数据挖掘问题,而且介绍了高级数据类型,例如文本、时间序列、离散序列、空间数据、图数据和社会网络。《数据挖掘:原理与实践》由基础篇和进阶篇组成。基础篇对应原书的第1~11章,进阶篇对应原书的第12~20章。

    基础章节:数据挖掘主要有四个“超级问题”,即聚类、分类、关联模式挖掘和异常分析,它们的重要性体现为许许多多的实际应用把它们当成基本构件。由此,数据挖掘研究者和实践者非常重视为这些问题设计有效且高效的方法。这些基础章节详细地讨论了数据挖掘领域针对这几个超级问题所提出的各类解决方法。

    领域章节:这些章节讨论不同领域的特殊方法,包括文本数据、时序数据、序列数据、图数据、空间数据等。这些章节多数可以认为是应用性章节,因为它们探索特定领域的特殊性问题。

    应用章节:计算机硬件技术和软件平台的发展导致了一些数据密集型应用的产生,如数据流系统、Web挖掘、社交网络和隐私保护。应用章节对这些话题进行了详细的介绍。前面所说的那些领域章节其实也集中讨论了由这些不同的数据类型而产生的各类应用。

    《数据挖掘:原理与实践》中文版分为基础篇和进阶篇,深入探讨了数据挖掘的各个方面,从基础知识到复杂的数据类型及其应用,捕捉了数据挖掘的各种问题领域。它不仅关注传统的数据挖掘问题,还引入了高级数据类型,例如文本、时间序列、离散序列、空间数据、图数据和社交网络数据。到目前为止,还没有一本书以如此全面和综合的方式探讨所有这些主题。

    基础篇:详细介绍了针对数据挖掘的四个主要问题(聚类、分类、关联模式挖掘和异常分析)的各种解决方法、用于文本数据领域的特定挖掘方法,以及对于数据流的挖掘应用。

    进阶篇:主要讨论了用于不同数据领域(例如时序数据、序列数据、空间数据、图数据)的特定挖掘方法,以及重要的数据挖掘应用(例如Web数据挖掘、排名、推荐、社交网络分析和隐私保护)。

    数据挖掘:原理与实践(基础篇)

    PC版

    http://product.china-pub.com/8077295

    移动版

    http://m.china-pub.com/touch/touchproduct.aspx?id=8077295

    数据挖掘:原理与实践(进阶篇)

    PC版

    http://product.china-pub.com/8077294

    移动版

    http://m.china-pub.com/touch/touchproduct.aspx?id=8077294

    数据挖掘:原理与实践(基础篇)(进阶篇)

     

    展开全文
  • ​一个优秀的数据分析师不仅要掌握基本的统计、数据库、数据分析方法、...今天我就用我的理解给大家介绍一下数据挖掘十大经典算法的原理,帮助大家快速理解。 数据挖掘算法分类 1、连接分析:PageRank。 2、相关分析:A

    ​一个优秀的数据分析师不仅要掌握基本的统计、数据库、数据分析方法、思维、数据分析工具和技能,还要掌握一些数据挖掘的思路,帮助我们挖掘出有价值的数据,这也是数据分析专家和一般数据分析师的差距之一。

    在这里插入图片描述

    数据挖掘主要分为三类:分类算法、聚类算法和相关规则,基本涵盖了当前商业市场对算法的所有需求。这三类包含了许多经典算法。市面上很多关于数据挖掘算法的介绍都是深奥难懂的。今天我就用我的理解给大家介绍一下数据挖掘十大经典算法的原理,帮助大家快速理解。

    数据挖掘算法分类

    1、连接分析:PageRank。

    2、相关分析:Apriori。

    3、分类算法:C4.5,简单的贝叶斯,SVM,KNN,Adaboost,CART。

    4、聚类算法:K-Means,EM。

    一、PageRank

    论文被引用的次数越多,其影响就越大。

    网页入口越多,入链质量越高,网页质量越高。

    PageRank原理

    网页的影响=阻尼影响+所有入链集合页面的加权影响之和。

    一个网页的影响:所有进入链的页面的加权影响之和。

    一个网页对其他网页的影响是:自身影响/链接数量。

    并非所有用户都是通过跳转链接来上网的,还有其他方式,比如直接输入网站访问。

    因此需要设置阻尼因子,代表用户根据跳转链接上网的概率。

    PageRank比喻说明

    1、微博

    一个人的微博粉丝数量不一定等于他的实际影响力,还要看粉丝的质量。

    如果是僵尸粉没用,但是如果是很多大V或者明星关注的话,影响力很大。

    2、店铺经营

    顾客较多的店铺质量较好,但要看顾客是否是托。

    3、兴趣

    对感兴趣的人或事投入相对较多的时间,对其相关的人和事也投入一定的时间。被关注的人或事越多,其影响力/受众就越大。

    关于阻尼因子

    1、通过邻居的影响来判断你的影响,但是如果你不能通过邻居来访问你,并不意味着你没有影响力,因为可以直接访问你,所以引入了阻尼因子的概念。

    2、海洋除了河流流经外,还有雨水,但下雨是随机的。

    3、提出阻尼系数,或者解决一些网站显然有大量的链(链),但影响很大。

    出链例子:hao123导航网页,出链多,入链少。

    入链例子:百度谷歌等搜索引擎,入链很多,出链很少。

    二、Apriori(相关分析)

    关联挖掘关系,从消费者交易记录中发现商品之间的关系。

    Apriori原理

    1、支持度

    商品组合出现的次数与总次数之比。

    五次购买,四次购买牛奶,牛奶支持度为4/5=0.8。

    五次购买,三次购买牛奶+面包,牛奶+面包支持3/5=0.6。

    2、置信度

    购买商品A,购买商品B的概率有多大,发生A时发生B的概率有多大。

    买了四次牛奶,其中两次买了啤酒,(牛奶->啤酒)的可信度是2/4=0.5。

    三次买啤酒,其中两次买牛奶,(啤酒->牛奶)的可信度为2/3-0.67。

    3、提升度

    衡量商品A的出现,提高商品B出现概率的程度。

    提升度(A->B)=置信度(A->B)/支持度(B)。

    提升度>1,有提升;提升度=1,无变化;提升度1,下降。

    4、项集频繁

    项集:可以是单一商品,也可以是商品组合。

    频繁的项集是支持度大于最小支持度的项集(MinSupport)。

    计算过程

    (1)从K=1开始,经常筛选项集。

    (2)在结果中,组合K+1项集,重新筛选。

    (3)循环1,2步。K-1项集的结果是最终结果,直到找不到结果。

    扩展:FP-Growth算法。

    Apriori算法需要多次扫描数据库,性能低,不适合大数据量。

    FP-growth算法,通过构建FP树的数据结构,将数据存储在FP树中,只需在构建FP树时扫描数据库两次,后续处理就不需要再访问数据库。

    比喻:啤酒和纸尿裤一起卖。

    沃尔玛通过数据分析发现,在美国有婴儿的家庭中,母亲通常在家照顾孩子,父亲去超市买尿布。

    父亲在买纸尿裤的时候,经常会搭配几瓶啤酒来奖励自己。因此,超市试图推出一种将啤酒和纸尿裤放在一起的促销手段,这实际上大大增加了纸尿裤和啤酒的销量。

    三、数据挖掘算法:AdaBoost

    AdaBoost原理

    简单来说,多个弱分类器训练成强分类器。

    将一系列弱分类器作为不同权重比组合的最终分类选择。

    计算过程

    1、基本权重初始化。

    2、奖励权重矩阵,通过现有的分类器计算错误率,选择错误率最低的分类器。

    3、通过分类器权重公式,减少正确的样本分布,增加错误的样本分布,获得新的权重矩阵和当前k轮的分类器权重。

    4、将新的权重矩阵带入上述步骤2和3,重新计算权重矩阵。

    5、迭代N轮,记录每轮最终分类器的权重,获得强分类器。

    AdaBoost算法比喻说明

    1、利用错题提高学习效率

    做对的题,下次少做点,反正都会。

    下次多做错题,集中在错题上。

    随着学习的深入,错题会越来越少。

    2、合理跨境提高利润

    苹果公司,软硬件结合,占据了手机市场的大部分利润,两个领域的知识结合产生了新的收益。

    四、数据挖掘算法:C4.5(决策树)

    决策就是对一个问题有多个答案,选择答案的过程就是决策。

    C4.5算法用于产生决策树,主要用于分类。

    C4.5计算信息增益率(ID3算法计算信息增益)。

    C4.5算法原理

    C4.5算法选择最有效的方法对样本集进行分裂,分裂规则是分析所有属性的信息增益率。

    信息增益率越大,意味着这个特征分类的能力越强,我们应该优先选择这个特征进行分类。

    比喻说明:挑西瓜。

    拿到一个西瓜,先判断它的线条。如果很模糊,就觉得不是好瓜。如果很清楚,就觉得是好瓜。如果稍微模糊一点,就考虑它的密度。如果密度大于一定值,就认为是好瓜,否则就是坏瓜。

    五、数据挖掘算法:CART(决策树)

    CART:Clasification And Regresion Tree,中文叫分类回归树,可以分类也可以回归。

    什么是分类树?回归树?

    分类树:处理离散数据,即数据类型有限的数据,输出样本类别。

    回归树:可以预测连续值,输出一个值,值可以在一定范围内获得。

    回归问题和分类问题的本质是一样的,就是对一个输入做一个输出预测,其区别在于输出变量的类型。

    CART算法原理

    CART分类树

    类似于C4.5算法,但属性选择的指标是基尼系数。

    基尼系数反映了样本的不确定性。基尼系数越小,样本之间的差异越小,不确定性越低。

    分类是一个降低不确定性的过程。CART在构建分类树时,会选择基尼系数最小的属性作为属性划分。

    回归树的CART

    以均方误差或绝对值误差为标准,选择均方误差或绝对值误差最小的特征。

    分类和回归数的比喻说明

    分类:预测明天是阴、晴还是雨。

    回归:预测明天的温度。

    六、数据挖掘算法:简单贝叶斯(条件概率)

    简单贝叶斯是一种简单有效的常用分类算法,在未知物体出现的情况下,计算各类出现的概率,取概率最大的分类。

    在这里插入图片描述

    算法原理

    假设输入的不同特征是独立的,基于概率论原理,通过先验概率P(A)、P(B)和条件概率计算出P(A|B)。

    P(A):先验概率,即在B事件发生前判断A事件概率。

    P(B|A):条件概率,事件B在另一个事件A已经发生的条件下发生的概率。

    P(A|B):后验概率,即B事件发生后重新评估A事件概率。

    比喻说明:对患者进行分类

    给定一个新病人,一个打喷嚏的建筑工人,计算他感冒的概率。

    在这里插入图片描述

    七、数据挖掘算法:SVM

    SVM:SupportVectorMachine,中文名为支持向量机,是一种常见的分类方法,最初是为二分类问题设计的,在机器学习中,SVM是一种有监督的学习模式。

    什么是监督学习和无监督学习?

    监督学习:即在现有类别标签的情况下,对样本数据进行分类。

    无监督学习:即在没有类别标签的情况下,样本数据按照一定的方法进行分类,即聚类。分类好的类别需要进一步分析,才能知道每个类别的特点。

    SVM算法原理

    找到间隔最小的样本点,然后拟合到这些样本点的距离和最大的线段/平面。

    硬间隔:数据线性分布,直接给出分类。

    软间隔:允许一定量的样本分类错误。

    核函数:非线性分布的数据映射为线性分布的数据。

    SVM算法比喻说明

    1、分隔桌上的一堆红球和篮球。

    桌上的红球和蓝球用一根线分成两部分。

    2、分隔盒子里的一堆红球和篮球。

    盒子里的红球和蓝球用平面分成两部分。

    八、数据挖掘算法:KNN(聚类)

    机器学习算法中最基本、最简单的算法之一,可以通过测量不同特征值之间的距离来分类。

    KNN算法原理

    计算待分类物体与其他物体之间的距离,预测K最近邻居数量最多的类别是该分类物体的类别。

    计算步骤。

    1.根据场景选择距离计算方法,计算待分类物体与其他物体之间的距离。

    2.统计最近的K邻居。

    3.对于K最近的邻居,最多的类别被预测为分类对象的类别。

    KNN算法比喻:近朱者赤,近墨者黑。

    九、数据挖掘算法:K-Means(聚类)

    K-means是一种无监督学习、生成指定K类的聚类算法,将每个对象分配到最近的聚类中心。

    在这里插入图片描述

    K-Means算法原理

    1.随机选择K点作为分类中心点。

    2.将每个点分配到最近的类,从而形成K类。

    3.重新计算每个类别的中心点。比如同一类别有10个点,那么新的中心点就是这10个点的中心点,一个简单的方法就是取平均值。

    K-Means算法比喻说明

    1、选组长

    每个人都随机选择K个组长,谁离得近,就是那个队列的人(计算距离,近的人聚在一起)。

    随着时间的推移,组长的位置在变化(根据算法重新计算中心点),直到选择真正的中心组长(重复,直到准确率最高)。

    2、Kmeans和Knn的区别

    Kmeans开班选组长,风水轮流转,直到选出最佳中心组长。

    Knn小弟加队,离那个班比较近,就是那个班。

    十、数据挖掘算法:EM(聚类)

    EM的英语是ExpectationMaximization,因此EM算法又称最大期望算法,也是一种聚类算法。

    EM和K-Means的区别:

    EM是计算概率,KMeans是计算距离。

    EM属于软聚类,同一样本可能属于多个类别;K-Means属于硬聚类,一个样本只能属于一个类别。因此,前者可以发现一些隐藏的数据。

    EM算法原理

    先估计一个大概率的可能参数,然后根据数据不断调整,直到找到最终确认参数。

    EM算法比喻说明:菜称重

    很少有人用称重菜肴,然后计算一半的重量来平分。

    大多数人的方法是:

    1、先把一部分分成菜A,然后把剩下的分成菜B。

    2、观察菜A和B里的菜是否一样多,哪个多就匀一点到少。

    3、然后观察碟子里的A和B是否一样多,重复,直到重量没有变化。

    其中,数据挖掘之后就需要把收集的有用的数据进行可视化处理方便人们直观感受数据的变化和重要性,通常数据分析师都会选择一些可视化辅助工具帮助自己更好的完成数据分析工作,比如基础的可视化工具有Excel、PPT和Xmind,但是对于企业来说,这些可视化工具提供的功能都太单一了,不能很好的满足可视化效果,很多数据分析师会选择Smartbi这款可视化工具,集齐数据挖掘、数据分析、数据可视化功能于一体的数据可视化工具,有着更方便的拖拉拽操作,能处理亿级的数据量,还有着可视化效果更好的自助仪表盘,能更好的满足现代企业报表需求。

    到这里十大算法已经简单介绍完成了。事实上,一般来说,常用算法已经被封装到仓库中,只要new生成相应的模型。数据分析师不仅要学会怎么收集有用的数据,也要对数据进行深度分析做出对企业更有利的决策,选择可视化工具Smartbi能有效的提升数据分析师的生产力。这些是一些结合个人经验和网上资料的心得体会,希望能对你学习数据挖掘有帮助。

    展开全文
  • 数据挖掘算法原理与实践:决策树第二关:决策树算法原理第三关:动手实现ID3决策树 第二关:决策树算法原理 #encoding=utf8 import numpy as np # 计算熵 def calcInfoEntropy(label): ''' input: label(narray)...

    感谢阳博导远程指导

    第二关:决策树算法原理

    #encoding=utf8
    import numpy as np
    
    # 计算熵
    def calcInfoEntropy(label):
        '''
        input:
            label(narray):样本标签
        output:
            InfoEntropy(float):熵
        '''
        #********* Begin *********#
        label_set = set(label)
        InfoEntropy = 0
        
        for temp_label in label_set:
            count = 0
            for j in range(len(label)):
                if label[j] == temp_label:
                    count += 1
            # 计算标签在数据集中出现的概率
            p = count / len(label)
            # 计算熵
            InfoEntropy -= p * np.log2(p)
    
        #********* End *********#
        return InfoEntropy
    
    #计算条件熵
    def calcHDA(feature,label,index,value):
        '''
        input:
            feature(ndarray):样本特征
            label(ndarray):样本标签
            index(int):需要使用的特征列索引
            value(int):index所表示的特征列中需要考察的特征值
        output:
            HDA(float):信息熵
        '''
        #********* Begin *********#
        count = 0
        # sub_feature和sub_label表示根据特征列和特征值分割出的子数据集中的特征和标签
        sub_feature = []
        sub_label = []
        for i in range(len(feature)):
            if feature[i][index] == value:
                count += 1
                sub_feature.append(feature[i])
                sub_label.append(label[i])
        pHA = count / len(feature)
        e = calcInfoEntropy(sub_label)
        HDA =  pHA * e
        #********* End *********#
        return HDA
    
    #计算信息增益
    def calcInfoGain(feature, label, index):
        '''
        input:
            feature(ndarry):测试用例中字典里的feature
            label(ndarray):测试用例中字典里的label
            index(int):测试用例中字典里的index,即feature部分特征列的索引。该索引指的是feature中第几个特征,如index:0表示使用第一个特征来计算信息增益。
        output:
            InfoGain(float):信息增益
        '''
        #********* Begin *********#
        # 得到指定特征列的值的集合
        base_e = calcInfoEntropy(label)
        f = np.array(feature)
        # 计算条件熵
        f_set = set(f[:, index])
        sum_HDA = 0
        # 计算信息增益
        for value in f_set:
            sum_HDA += calcHDA(feature, label, index, value)
        InfoGain =  base_e - sum_HDA
        #********* End *********#
        return InfoGain
    
    

    第三关:动手实现ID3决策树

    import numpy as np
    
    # 计算熵
    def calcInfoEntropy(label):
        '''
        input:
            label(narray):样本标签
        output:
            InfoEntropy(float):熵
        '''
        label_set = set(label)
        InfoEntropy = 0
        for l in label_set:
            count = 0
            for j in range(len(label)):
                if label[j] == l:
                    count += 1
            # 计算标签在数据集中出现的概率
            p = count / len(label)
            # 计算熵
            InfoEntropy -= p * np.log2(p)
        return InfoEntropy
    
    #计算条件熵
    def calcHDA(feature,label,index,value):
        '''
        input:
            feature(ndarray):样本特征
            label(ndarray):样本标签
            index(int):需要使用的特征列索引
            value(int):index所表示的特征列中需要考察的特征值
        output:
            HDA(float):信息熵
        '''
        count = 0
        # sub_feature和sub_label表示根据特征列和特征值分割出的子数据集中的特征和标签
        sub_feature = []
        sub_label = []
        for i in range(len(feature)):
            if feature[i][index] == value:
                count += 1
                sub_feature.append(feature[i])
                sub_label.append(label[i])
        pHA = count / len(feature)
        e = calcInfoEntropy(sub_label)
        HDA = pHA * e
        return HDA
    
    #计算信息增益
    def calcInfoGain(feature, label, index):
        '''
        input:
            feature(ndarry):测试用例中字典里的feature
            label(ndarray):测试用例中字典里的label
            index(int):测试用例中字典里的index,即feature部分特征列的索引。该索引指的是feature中第几个特征,如index:0表示使用第一个特征来计算信息增益。
        output:
            InfoGain(float):信息增益
        '''
        base_e = calcInfoEntropy(label)
        f = np.array(feature)
        # 得到指定特征列的值的集合
        f_set = set(f[:, index])
        sum_HDA = 0
        # 计算条件熵
        for value in f_set:
            sum_HDA += calcHDA(feature, label, index, value)
        # 计算信息增益
        InfoGain = base_e - sum_HDA
        return InfoGain
    
    # 获得信息增益最高的特征
    def getBestFeature(feature, label):
        '''
        input:
            feature(ndarray):样本特征
            label(ndarray):样本标签
        output:
            best_feature(int):信息增益最高的特征
        '''
        #*********Begin*********#
        max_infogain = 0
        best_feature = 0
        for i in range(len(feature[0])):
            infogain = calcInfoGain(feature, label, i)
            if infogain > max_infogain:
                max_infogain = infogain
                best_feature = i
        #*********End*********#
        return best_feature
    
    #创建决策树
    def createTree(feature, label):
        '''
        input:
            feature(ndarray):训练样本特征
            label(ndarray):训练样本标签
        output:
            tree(dict):决策树模型    
        '''
        #*********Begin*********#
        # 样本里都是同一个label没必要继续分叉了
        if len(set(label)) == 1:
            return label[0]
        # 样本中只有一个特征或者所有样本的特征都一样的话就看哪个label的票数高
        if len(feature[0]) == 1 or len(np.unique(feature, axis=0)) == 1:
            vote = {}
            for l in label:
                if l in vote.keys():
                    vote[l] += 1
                else:
                    vote[l] = 1
            max_count = 0
            vote_label = None
            for k, v in vote.items():
                if v > max_count:
                    max_count = v
                    vote_label = k
            return vote_label
    
        # 根据信息增益拿到特征的索引
        best_feature = getBestFeature(feature, label)
        tree = {best_feature: {}}
        f = np.array(feature)
        # 拿到bestfeature的所有特征值
        f_set = set(f[:, best_feature])
        # 构建对应特征值的子样本集sub_feature, sub_label
        for v in f_set:
            sub_feature = []
            sub_label = []
            for i in range(len(feature)):
                if feature[i][best_feature] == v:
                    sub_feature.append(feature[i])
                    sub_label.append(label[i])
            # 递归构建决策树
            tree[best_feature][v] = createTree(sub_feature, sub_label)
        #*********End*********#
        return tree
    
    #决策树分类
    def dt_clf(train_feature,train_label,test_feature):
        '''
        input:
            train_feature(ndarray):训练样本特征
            train_label(ndarray):训练样本标签
            test_feature(ndarray):测试样本特征
        output:
            predict(ndarray):测试样本预测标签     
        '''
        #*********Begin*********#
        result = []
        tree = createTree(train_feature,train_label)
    
        def classify(tree, feature):
            if not isinstance(tree, dict):
                return tree
            t_index, t_value = list(tree.items())[0]
            f_value = feature[t_index]
            if isinstance(t_value, dict):
                classLabel = classify(tree[t_index][f_value], feature)
                return classLabel
            else:
                return t_value
    
        for feature in test_feature:
            result.append(classify(tree, feature))
    
        predict = np.array(result)
        #*********End*********#
        return predict
    
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • 记一次数据挖掘:中文语句情绪多标签分类问题将中文语句矩阵数字化对8个类别进行模型建立,找到8个最适合的机器学习模型 将中文语句矩阵数字化 import pandas as pd import pickle 先导入pandas库,该库提供了csv...

    将中文语句矩阵数字化

    import pandas as pd
    import pickle
    

    先导入pandas库,该库提供了csv文件的相关数据分析功能,是我们数据挖掘必须学会使用的库。
    之后导入pickle库,该库是用于将中文语句中使用频数超过10次的字或词收集的字典序列化。

    train_df = pd.read_csv('../yangqf/Desktop/Train.csv',encoding='gb18030')
    train_df.head()
    

    读取Train.csv文件,采用gb18030的方式解码,并显示该数据集中的前五行数据
    在这里插入图片描述

    jieguoList = ['Love', 'Sorrow', 'Hate', 'Anxiety', 'Surprise', 'Expect', 'Joy', 'Anger']
    train_df.info()
    

    jieguoList列表用于存储分类类别,info()用于显示数据集的基本数据情况
    在这里插入图片描述

    train_df["Text"][0]
    

    显示第一个数据的Text列文字
    在这里插入图片描述

    length = len(train_df) #数据的大小
    Total_dict={} #将数据集中所有出现的字词编号并放入该字典中
    icount = 0 #计数器
    ziShu_dict = {} #字数字典
    
    for i in range(length):  #该for循环用于让字数字典所有字词的计数先初始化为0 
        Str = ""
        for j in range(len(train_df["Text"][i])):
            if train_df["Text"][i][j] != ' ':
                Str = "{0}{1}".format(Str,train_df["Text"][i][j])
                continue
            ziShu_dict[Str] = 0 #字典内的数据显示如:{"她们":0,"都":0,"睡":0,"蹑手蹑脚":0,……}
            Str = ""
    
    for i in range(length): #该for循环用于将字数字典内的字词进行分别计数,统计数据集所有的对应的字词数量
    						#Total_dict字典将所有的字词进行收集并记录序号,数据显示如:
    						#{她们":0,"都":1,"睡":2,"蹑手蹑脚":3,……}
        Str = ""
        for j in range(len(train_df["Text"][i])):
            if train_df["Text"][i][j] != ' ':
                Str = "{0}{1}".format(Str,train_df["Text"][i][j])
                continue
            if Str in Total_dict:
                ziShu_dict[Str] += 1
            else:
                Total_dict[Str] = icount
                icount+=1
            Str = ""
    print(len(Total_dict))  #输出总字典的长度
    print(len(ziShu_dict))  #输出字数字典的长度,会与总字典长度一样
    

    在这里插入图片描述

    icount = 0
    for i in range(len(Total_dict)): #该for循环是删除字数字典中字词出现数量小于10次的字词,也是为了防止出			 
                                     #现过拟合的现象,减小特征向量的空间,减小学习模型的复杂度,并把字数字             
                                     #典改成序号排序的字典,类似于Total_dict
        List = []
        temp = list(Total_dict.keys())[list(Total_dict.values()).index(i)]  #该语句作用是根据字典的
                                                                            #value值提取对应的Key
        if ziShu_dict[temp] < 10:
            del ziShu_dict[temp]
        else:
            ziShu_dict[temp] = icount
            icount += 1
    
    for i in range(len(jieguoList)): #该for循环是为了创建多个分类列,因为我们要处理的是多标签的分类问题,          
    								 #所以先将问题转化为二分类的问题,比如提取Love类,将Label里有Love的
    								 #标记为1,没有Love的标记为0,这样可以创建一个专门判断Love的学习模
    								 #型,以此类推,总共需要创建8个学习模型。
        List = []
        for j in range(length):
            if jieguoList[i] in train_df["Labels"][j] :
                List.append(1)
            else:
                List.append(0)
        train_df[jieguoList[i]] = List
    
    
    icount = 0
    
    for i in range(len(ziShu_dict)): #for循环用于将中文语句数字化,比如'他们'这个词在总体数据集中出现超过
    							     #了10次,便创建一列,将它设为列名为0,接着判断所有语句中是否出现了它
    							     #,如果出现了,便将0列设为1,没有出现设为0。依次类推,可以将中文数字
    							     #化
        List = []
        temp = list(ziShu_dict.keys())[list(ziShu_dict.values()).index(i)]
        for j in range(length):
            if temp in train_df["Text"][j] :
                List.append(1)
            else:
                List.append(0)
        icount += 1
        print(len(ziShu_dict)-icount)
        train_df[i] = List
    
    with open('Total_dict.dict', 'wb') as handle:  #用于序列化Total_dict字典,保存在磁盘上,便于下次用在
    											   #测试集上的中文序列化。
        pickle.dump(Total_dict, handle, protocol=pickle.HIGHEST_PROTOCOL)
    
    with open('ziShu_dict.dict', 'wb') as handle:  #原理同上
        pickle.dump(ziShu_dict, handle, protocol=pickle.HIGHEST_PROTOCOL)
    
    print(ziShu_dict)
    print(len(ziShu_dict))
    train_df.to_csv('../yangqf/Desktop/zhongyaoshuju.csv', index=False)
    

    输出字数字典,并输出其长度,最后将数字化后的数据集保存在磁盘上,便于之后读取处理。
    在这里插入图片描述
    在这里插入图片描述

    train_df.head()
    

    在这里插入图片描述

    对8个类别进行模型建立,找到8个最适合的机器学习模型

    # data analysis and wrangling
    import pandas as pd
    import numpy as np
    import random as rnd
    import pickle
    # visualization
    import seaborn as sns
    import matplotlib.pyplot as plt
    %matplotlib inline
    
    # machine learning
    from sklearn.linear_model import LogisticRegression
    from sklearn.svm import SVC, LinearSVC
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.naive_bayes import GaussianNB
    from sklearn.linear_model import Perceptron
    from sklearn.linear_model import SGDClassifier
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.model_selection import train_test_split
    from sklearn.externals import joblib
    

    导入数据分析处理的库和可视化的库和机器学习的库

    # 读取数据
    train_df = pd.read_csv('../yangqf/Desktop/zhongyaoshuju.csv')
    x = train_df.drop("ID",axis = 1) #丢弃数据集中没用的ID列
    x = x.drop("Text",axis=1) #接着丢弃没用的“Text”列
    x = x.drop("Labels",axis=1) #再丢弃没用的"Labels"列
    x_love = x.drop(['Sorrow', 'Hate', 'Anxiety', 'Surprise', 'Expect', 'Joy', 'Anger'], axis=1, inplace=True) #留下Love列,其他类都丢弃
    x_love_train = x.drop("Love",axis=1)  #丢弃完Love这个Labels后,剩余的便是要求的训练集特征向量
    y_love_train = x['Love'] #将Love列当做给训练集标签列
    
    # 将特征划分到 X 中,标签划分到 Y 中
    # 使用train_test_split函数划分数据集(训练集占75%,测试集占25%)
    x_love_train, x_love_test, y_love_train, y_love_test = train_test_split(x_love_train, y_love_train,test_size=0.25)
    
    # Logistic Regression
    
    love_logreg = LogisticRegression()
    love_logreg.fit(x_love_train, y_love_train)
    y_love_predict = love_logreg.predict(x_love_test)
    acc_log = round(love_logreg.score(x_love_test, y_love_test) * 100, 2)
    print(acc_log)
    

    经过与其他机器学习模型比较之后,发现Logistic回归模型的效果更好,故对Love类的判断采用逻辑回归模型。在这里插入图片描述

    x = train_df.drop(['ID','Text','Labels','Love','Hate','Anxiety','Surprise','Expect','Joy','Anger'],axis=1)
    x
    x_sorrow_train = x.drop("Sorrow",axis=1)
    y_sorrow_train = x['Sorrow']
    # 使用train_test_split函数划分数据集(训练集占75%,测试集占25%)
    x_sorrow_train, x_sorrow_test, y_sorrow_train, y_sorrow_test = train_test_split(x_sorrow_train, y_sorrow_train,test_size=0.25)
    
    # Random Forest
    
    sorrow_random_forest = RandomForestClassifier(n_estimators=100)
    sorrow_random_forest.fit(x_sorrow_train, y_sorrow_train)
    # Y_pred = random_forest.predict(X_test)
    # random_forest.score(X_train, Y_train)
    acc_random_forest = round(sorrow_random_forest.score(x_sorrow_test, y_sorrow_test) * 100, 2)
    acc_random_forest
    

    原理同上,将sorrow列单独拎出来判断,发现随机森林模型的判断更好,顾选择其判断。

    x = train_df.drop(['ID','Text','Labels','Love','Sorrow','Anxiety','Surprise','Expect','Joy','Anger'],axis=1)
    x
    x_hate_train = x.drop("Hate",axis=1)
    y_hate_train = x['Hate']
    # 使用train_test_split函数划分数据集(训练集占75%,测试集占25%)
    x_hate_train, x_hate_test, y_hate_train, y_hate_test = train_test_split(x_hate_train, y_hate_train,test_size=0.25)
    # Random Forest
    
    hate_random_forest = RandomForestClassifier(n_estimators=100)
    hate_random_forest.fit(x_hate_train, y_hate_train)
    # Y_pred = random_forest.predict(X_test)
    # random_forest.score(X_train, Y_train)
    acc_random_forest = round(hate_random_forest.score(x_hate_test, y_hate_test) * 100, 2)
    print(acc_random_forest)
    
    x = train_df.drop(['ID','Text','Labels','Love','Sorrow','Hate','Surprise','Expect','Joy','Anger'],axis=1)
    x
    x_anxiety_train = x.drop("Anxiety",axis=1)
    y_anxiety_train = x['Anxiety']
    # 使用train_test_split函数划分数据集(训练集占75%,测试集占25%)
    x_anxiety_train, x_anxiety_test, y_anxiety_train, y_anxiety_test = train_test_split(x_anxiety_train, y_anxiety_train,test_size=0.25)
    
    # Random Forest
    
    anxiety_random_forest = RandomForestClassifier(n_estimators=100)
    anxiety_random_forest.fit(x_anxiety_train, y_anxiety_train)
    # Y_pred = random_forest.predict(X_test)
    # random_forest.score(X_train, Y_train)
    acc_random_forest = round(anxiety_random_forest.score(x_anxiety_test, y_anxiety_test) * 100, 2)
    print(acc_random_forest)
    
    x = train_df.drop(['ID','Text','Labels','Love','Sorrow','Hate','Anxiety','Expect','Joy','Anger'],axis=1)
    x
    x_surprise_train = x.drop("Surprise",axis=1)
    y_surprise_train = x['Surprise']
    # 使用train_test_split函数划分数据集(训练集占75%,测试集占25%)
    x_surprise_train, x_surprise_test, y_surprise_train, y_surprise_test = train_test_split(x_surprise_train, y_surprise_train,test_size=0.25)
    
    # Random Forest
    
    surprise_random_forest = RandomForestClassifier(n_estimators=100)
    surprise_random_forest.fit(x_surprise_train, y_surprise_train)
    # Y_pred = random_forest.predict(X_test)
    # random_forest.score(X_train, Y_train)
    acc_random_forest = round(surprise_random_forest.score(x_surprise_test, y_surprise_test) * 100, 2)
    print(acc_random_forest)
    
    x = train_df.drop(['ID','Text','Labels','Love','Sorrow','Hate','Anxiety','Surprise','Joy','Anger'],axis=1)
    x
    x_expect_train = x.drop("Expect",axis=1)
    y_expect_train = x['Expect']
    # 使用train_test_split函数划分数据集(训练集占75%,测试集占25%)
    x_expect_train, x_expect_test, y_expect_train, y_expect_test = train_test_split(x_expect_train, y_expect_train,test_size=0.25)
    
    # Random Forest
    
    expect_random_forest = RandomForestClassifier(n_estimators=100)
    expect_random_forest.fit(x_expect_train, y_expect_train)
    # Y_pred = random_forest.predict(X_test)
    # random_forest.score(X_train, Y_train)
    acc_random_forest = round(expect_random_forest.score(x_expect_test, y_expect_test) * 100, 2)
    print(acc_random_forest)
    
    x = train_df.drop(['ID','Text','Labels','Love','Sorrow','Hate','Anxiety','Surprise','Expect','Anger'],axis=1)
    x
    x_joy_train = x.drop("Joy",axis=1)
    y_joy_train = x['Joy']
    # 使用train_test_split函数划分数据集(训练集占75%,测试集占25%)
    x_joy_train, x_joy_test, y_joy_train, y_joy_test = train_test_split(x_joy_train, y_joy_train,test_size=0.25)
    # Random Forest
    
    joy_random_forest = RandomForestClassifier(n_estimators=100)
    joy_random_forest.fit(x_joy_train, y_joy_train)
    # Y_pred = random_forest.predict(X_test)
    # random_forest.score(X_train, Y_train)
    acc_random_forest = round(joy_random_forest.score(x_joy_test, y_joy_test) * 100, 2)
    print(acc_random_forest)
    
    x = train_df.drop(['ID','Text','Labels','Love','Sorrow','Hate','Anxiety','Surprise','Expect','Joy'],axis=1)
    x
    x_anger_train = x.drop("Anger",axis=1)
    y_anger_train = x['Anger']
    # 使用train_test_split函数划分数据集(训练集占75%,测试集占25%)
    x_anger_train, x_anger_test, y_anger_train, y_anger_test = train_test_split(x_anger_train, y_anger_train,test_size=0.25)
    # Random Forest
    
    anger_random_forest = RandomForestClassifier(n_estimators=100)
    anger_random_forest.fit(x_anger_train, y_anger_train)
    # Y_pred = random_forest.predict(X_test)
    # random_forest.score(X_train, Y_train)
    acc_random_forest = round(anger_random_forest.score(x_anger_test, y_anger_test) * 100, 2)
    print(acc_random_forest)
    

    重复上述过程,便可以得到8个机器学习模型,便于之后对测试集类别进行判断。

    joblib.dump(love_logreg, '../yangqf/Desktop/xueximoxing/love_Logistic.model')#也可以使用文件对象
    joblib.dump(sorrow_random_forest, '../yangqf/Desktop/xueximoxing/sorrow_random_forest.model')#也可以使用文件对象
    joblib.dump(hate_random_forest, '../yangqf/Desktop/xueximoxing/hate_random_forest.model')#也可以使用文件对象
    joblib.dump(anxiety_random_forest, '../yangqf/Desktop/xueximoxing/anxiety_random_forest.model')#也可以使用文件对象
    joblib.dump(surprise_random_forest, '../yangqf/Desktop/xueximoxing/surprise_random_forest.model')#也可以使用文件对象
    joblib.dump(expect_random_forest, '../yangqf/Desktop/xueximoxing/expect_random_forest.model')#也可以使用文件对象
    joblib.dump(joy_random_forest, '../yangqf/Desktop/xueximoxing/joy_random_forest.model')#也可以使用文件对象
    joblib.dump(anger_random_forest, '../yangqf/Desktop/xueximoxing/anger_random_forest.model')#也可以使用文件对象
    

    将所有学习后的模型进行序列化之后,保存在磁盘上。

    这里只是验证打分了模型,之后要记得把所有数据都用上去建立新模型。

    展开全文
  • 1分类的概念及分类器的评判分类数据挖掘中的一个重要课题。分类的目的是学会一个分类函数或分类模型(也常常称作分类器),该模型能把数据库的数据项映射到给定类别的某一个。分类可用于提取描述重要数据类的...
  • 数据挖掘概论(参考书:数据挖掘原理、方法及Python应用实践教程) 1.数据挖掘含义 数据挖掘(data mining)就是利用一系列技术和方法从海量数据找出隐藏于其中的潜在、有用的新知识的过程。在庞大的数据找到有...
  • 数据挖掘是一个动态、强势快速扩展的领域。数据挖掘研究的主要问题,可划分为五组:挖掘方法、用户交互、有效性与可伸缩性、数据类型的多样性、数据挖掘与社会。 一、挖掘方法 目前大牛们已经开发了一些数据挖掘方法...
  • 数据挖掘任务主要有很多种,常见的有分类、聚类、预测等,若按算法可分为两大类:无监督学习、有监督学习。 1.分类学习 分类就是找出一个类别的概念描述,它代表了这类数据的整体信息,即该类的内涵描述,并用...
  • 本实验课程是计算机、智能、物联网等专业学生的一门专业课程,通过实验,帮助学生更好地掌握数据挖掘相关概念、技术、原理、应用等;通过实验提高学生编写实验报告、总结实验结果的能力;使学生对机器学习算法、数据...
  • 一、 贝叶斯分类器、 二、 贝叶斯分类器处理多属性数据集方案
  • 它并非像其他的分类算法先通过训练建立分类模型.,而是一种被动的分类过程.它是边测试边训练建立分类模型.算法的一般描述过程如下:1.首先计算每个测试样本点到其他每个点的距离.这个距离可以是欧氏距离,...
  • 这里写自定义目录标题数据挖掘算法原理与实践:k-近邻任务代码1代码2knn算法思想 数据挖掘算法原理与实践:k-近邻 任务 1.本关任务:使用python实现方法,找出目标样本最近的k个样本。 2.使用python实现knn算法,并...
  • 第1关:决策树算法思想 ...第2关:决策树算法原理 任务描述 本关任务:根据本关所学知识,完成calcInfoGain函数。 相关知识 为了完成本关任务,你需要掌握: 信息熵 条件熵 信息增益 ...
  • 线性回归是属于机器学习里面的监督学习,与分类问题不同的是,在回归问题,其目标是通过对训练样本的学习,得到从样本特征到样本标签直接的映射,其中,在回归问题,样本的标签是连续值。 本实训项目的主要...
  • matlab实现数据挖掘

    2021-04-21 22:36:49
    实验一:matlab 实现 apriori 算法源代码一、实验目的通过实验,加深数据挖掘中一个重要方法——关联分析的认识,其经典算法为 apriori 算法, 了解影响 apriori 算法......题目:matlab 实现 Kmeans 聚类算法 姓 名 吴...
  • 数据挖掘个人理解

    2021-11-02 20:03:45
    <1>...4.分析数据常用方法:分类,回归分析,聚类,关联规则,神经网络方法,Web数据挖掘 5.常用工具:一般分析用的软件包(K-Miner,TipDm,GDM),针对特定功能或产业研发的软件(KD1),整合DS
  • 湖南科技大学数据挖掘复习提纲

    千次阅读 多人点赞 2021-01-03 20:32:17
     KDD(数据库的知识发现)的分类步骤及其功能 1、问题定义 2、数据采集 3、数据预处理(含五个步骤):数据清洗 、数据转换 、 数据描述、特征选择 、特征抽取 4、数据挖掘 5、模式评估 2.数据分类的步骤及其基本...
  • 本议题试图以实例的形式,用尽量通俗的方式,针对性别预测这个分类问题,来谈一下数据挖掘基本的处理流程,常见的算法和算法的选择等。 讲师:王琪,友盟数据挖掘工程师,武汉大学硕士,工作涉及友盟的各类数据挖掘...
  • 机器学习原理与实践 pandas数据处理 Matplotlib可视化 XGBOOST, LIGHTGBM, GBDT等常用大杀器简介 知识点总结 参考上图,我们能看出: 训练集准确度:XGBoost = LightGBM(明确类别特征)>LightGBM(不明确类别特征
  • 数据挖掘期末复习速成大法 华南农业大学

    千次阅读 多人点赞 2021-01-13 20:23:38
    速成《数据挖掘》宝典,博主用通俗易懂的方式详解考试重点和难点。适用于华南农业大学 计算机科学与技术《数据挖掘》课程(新大纲)
  • 分类模型是监督学习的一种,需要样本支撑进行模型构建,其输入可以是连续性也可以是离散型的变量,输出则是提前限定的离散分类标签,在实际使用根据分类标签的种类可以分为二分类和多分类问题。 回归算法的策略...
  • 从第一天的baseline学习,主要学习到了未学过的pandas处理大数据集,内存优化的方式。 代码部分如下: def reduce_mem_usage(df): #df.memory_usage() 为一个api可以查看dataframe每一列的内存占用情况 #sum...
  •   数据挖掘的基本任务包括利用分类与预测、聚类分析、关联规则、时序模式、偏差检测、智能推荐等方法,帮助企业提取数据蕴含的商业价值,提高企业的竞争力。   对于餐饮企业来说,数据挖掘的基本任务就是从...
  • 数据挖掘算法一:K近邻原理及python实现 1 原理 1.1 绪论 k近邻算法(k-nearest neighbor, k-NN)是一种基本分类与回归方法,多用于分类。其输入为实例的特征向量,对应于特征空间的点;输出为实例的类别,可以取...
  • 数据挖掘复习

    2021-03-10 15:23:54
    目前数据挖掘的主要研究内容包括基础理论、发现算法、数据仓库、可视化技术、定性定量互换模型、知识表示方法、发现知识的维护和再利用、半结构化和非结构化数据的知识发现以及Web数据挖掘等。
  • 一、实验项目名称:数据挖掘在零售业的应用 二、实验目的与要求: 通过项目的训练学习,了解数据挖掘在零售业应用状况,掌握数据挖掘在零售业分析方法及过程。 三、实验原理: (1)关联分析 (2)关联规则...
  • 一、实验项目名称:数据挖掘在风险分析的应用 二、实验目的与要求: 通过项目的训练学习,了解数据挖掘在风险分析应用状况,掌握数据挖掘在风险分析方法及过程。 三、实验原理: (1)财务数据的理解 (2)算法...
  • 数据是新时代的石油。”——Clive Humby在当今的人工智能时代,数据分析和挖掘似乎已经是一个很古老的话题。这也难怪,对数据的分析甚至可以追溯到中国第一经—《易经》这部远古文明的产...
  • 数据挖掘论文一:《数据挖掘中的属性选择偏差抑制算法研究》摘要:决策树算法广泛应用于数据挖掘领域之.属性选择是决策树方法挖掘效率的关键,但ID3方法和C4.5方法在选择属性时,都会产生一定程度的选择偏差.据此,该...
  • 公众号后台回复“图书“,了解更多号主新书内容 作者:luanhz 来源:小数志导读从事数据挖掘相关工作的人肯定都知道XGBoost算法,这个曾经闪耀于数据挖掘竞赛的一代神器...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,530
精华内容 14,212
关键字:

数据挖掘中分类的原理