精华内容
下载资源
问答
  • 文档分类算法总结

    2016-03-21 20:36:11
    文档分类的概念文档分类就是将一篇文档自动指定到几个预定义的文本类别中。向量空间模型文档分类多使用向量空间模型(VSM,vector space model),向量空间模型将文档中提取出若干特征词,按照特征词出现的的频率,将...

    文档分类的概念

    文档分类就是将一篇文档自动指定到几个预定义的文本类别中。

    向量空间模型

    文档分类多使用向量空间模型(VSM,vector space model),向量空间模型将文档中提取出若干特征词,按照特征词出现的的频率,将文本转换成空间中的点,通过比较点之间的距离确定文档的类别。

    机器学习算法

    机器学习算法分为两个阶段,第一阶段是学习阶段,第二阶段是分类阶段,学习阶段使用训练集构造分类器进行分类

    朴素贝叶斯算法

    基本思想:
    根据贝叶斯公式:
    文档d属于类c的概率:
    p(c∣d)=p(c)∗p(d∣c)/p(d)p(c|d)=p(c)*p(d|c)/p(d)p(cd)=p(c)p(dc)/p(d)
    p©为所有item属于类别c的item的概率,即属于c类的item的个数除以总item的数量
    p(d|c)为属于c类别的某个item为文本d的概率
    p(d)为所有item中文档d出现的概率
    对于每个文档d,对于每个类别c1,c2 ……cn求出p(d|ci),其中最大值对应的类别就是d所属的类别。
    p(d)对于每个类都相同,设计算法的时候不用考虑
    对于p(d|c),d可以被表示为d向量,由n个关键词出现的频率组成,则d=(a1,a2,……,an)d=(a1,a2,……,an)d=(a1,a2,,an),其中a1到an线性独立
    p(d∣c)=p(a1∣c)∗p(a2∣c)∗p(a3∣c)……p(an∣c)p(d|c)=p(a1|c)*p(a2|c)*p(a3|c)……p(an|c)p(dc)=p(a1c)p(a2c)p(a3c)p(anc)
    学习阶段:
    针对训练集合求每个类别的概率p©
    对文档进行分词,求每个特征值a对应每个类别的p(ai∣c)p(ai|c)p(aic)
    分类阶段:
    针对每个待分类集合,将其提取特征词,按照特征向量求p(ai∣c)p(ai|c)p(aic)
    p(ai∣c)∗p(c)p(ai|c)*p(c)p(aic)p(c)求最大值,最大值即为所在的类别。

    KNN算法

    基本思想:
    其维护一个长度为k的优先队列,每次分类的时候调整优先队列,对每一个待分类的item和每一个训练item比较距离,使最后队列中的item为与待分类item的距离最邻近的k个item,最后取这k个item中多数派的类别为所需要的类别。
    学习阶段:随机构建k队列
    分类阶段:遍历待分类文档集合,对每一个item与训练集中的所有item求距离,调整k队列,使队列中的元素为训练集与中待分类item距离最近的前k个item,最后根据k队列的组成确定待测试item的类别。

    展开全文
  • 分类算法技术文档

    2017-10-25 17:03:07
    贝叶斯算法的详细介绍。贝叶斯算法的详细介绍。贝叶斯算法的详细介绍。贝叶斯算法的详细介绍。
  • MYSQL无限分类算法技术文档——MYSQL中分层数据的管理,不解MYSQL高级数据管理的相关技巧,包括了一些必要的SQL语句和高级数据管理的讲解,像邻接表模型、检索整树、检索所有叶子节点、检索单一路径、邻接表模型的...
  • 简介 文本分类作为自然语言处理任务之一,被广泛应用于解决各种商业领域的问题。...文本分类属于有监督机器学习任务,这是因为文本分类任务利用一个包含文本/文档及其对应类标的有标注数据集来训练一...

    简介

    文本分类作为自然语言处理任务之一,被广泛应用于解决各种商业领域的问题。文本分类的目的是将 文本/文档 自动地归类为一种或多种预定义的类别。常见的文本分类应用如下:

    • 理解社交媒体用户的情感

    • 识别垃圾邮件与正常邮件

    • 自动标注用户的查询

    • 将新闻按已有的主题分类

    主要步骤

    文本分类属于有监督机器学习任务,这是因为文本分类任务利用一个包含文本/文档及其对应类标的有标注数据集来训练一个分类器。一个端到端的文本分类流程包括四个主要环节:

    1. 数据集准备: 第一步为数据准备,这一步包括数据加以及基本的预处理工作。数据集之后会被分割的训练集与验证集。

    2. 特征工程: 第二步为特征工程,在这一步中,原始数据会转变为适用于机器学习模型的特征。这一步还包括从已有数据中构建新的特征的过程。

    3. 模型训练: 最后一步为模型构建,在这一步中机器学习模型会在一个有标注数据集上进行训练。

    4. 提升文本分类器的性能: 在这篇文章中,我们还会关注各种提升文本分类器性能的方法。

    特征工程的分类

    原始数据会被转换为特征向量并且会从已有的数据中构建出新的特征。为了从我们的数据集中提取出相关的特征,我们会实现以下各种想法。

    2.1 以计数向量为特征

    2.2 TF-IDF 向量为特征

    • 词汇级

    • N-Gram 级

    • 字符级

    2.3 以词向量为特征

    2.4 基于 文本/自然语言处理 的特征

    2.5 以主题模型为特征

    展开全文
  • 朴素贝叶斯算法 朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法。 最为广泛的两种分类模型是决策树模型(Decision Tree Model)和朴素贝叶斯模型(Naive Bayesian Model,NBM)。和决策树模型相比,朴素...

    朴素贝叶斯算法

    朴素贝叶斯法是基于贝叶斯定理特征条件独立假设的分类方法。
    最为广泛的两种分类模型是决策树模型(Decision Tree Model)和朴素贝叶斯模型(Naive Bayesian Model,NBM)。和决策树模型相比,朴素贝叶斯分类器(Naive Bayes Classifier 或 NBC)发源于古典数学理论,有着坚实的数学基础,以及稳定的分类效率。同时,NBC模型所需估计的参数很少,对缺失数据不太敏感,算法也比较简单。理论上,NBC模型与其他分类方法相比具有最小的误差率。但是实际上并非总是如此,这是因为NBC模型假设属性之间相互独立,这个假设在实际应用中往往是不成立的,这给NBC模型的正确分类带来了一定影响。

    朴素贝叶斯算法(Naive Bayesian algorithm) 是应用最为广泛的分类算法之一。
    朴素贝叶斯方法是在贝叶斯算法的基础上进行了相应的简化,即假定给定目标值时属性之间相互条件独立。也就是说没有哪个属性变量对于决策结果来说占有着较大的比重,也没有哪个属性变量对于决策结果占有着较小的比重。虽然这个简化方式在一定程度上降低了贝叶斯分类算法的分类效果,但是在实际的应用场景中,极大地简化了贝叶斯方法的复杂性。

    贝叶斯方法

    贝叶斯方法是以贝叶斯原理为基础,使用概率统计的知识对样本数据集进行分类。由于其有着坚实的数学基础,贝叶斯分类算法的误判率是很低的。贝叶斯方法的特点是结合先验概率和后验概率,即避免了只使用先验概率的主观偏见,也避免了单独使用样本信息的过拟合现象。贝叶斯分类算法在数据集较大的情况下表现出较高的准确率,同时算法本身也比较简单。

    简单文档分类实例

    import numpy as np
    
    ## 简单文档分类——朴素贝叶斯算法
    
    '''
    创建实验数据集(假设每个样本已经被分割完成)
    返回值分别是 X_train, y_train
    X_train:表示训练的样本
    y_train:表示对应训练样本的分类结果
    '''
    def loadDataSet():
        X_train = [
            ['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
            ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
            ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
            ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
            ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
            ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']
        ]  # 切分好的词条
        y_train = [0, 1, 0, 1, 0, 1]  # 类别标签向量,1代表侮辱性词汇,0代表非侮辱性词汇
        return X_train, y_train
    
    '''
    创建词汇表
    trainData:训练集trainData(每句话代表一条数据),每句话已被切割成单词了
    vocabList:训练集中所有的单词(无重复)
    '''
    def createVocabList(trainData):
        vocabSet = set()                    # 创建一条空的集合
        # 遍历训练集dataSet(每句话代表一条数据)中的每句话(已被切割成单词了)
        for doc in trainData:
            vocabSet = vocabSet | set(doc)  # 取并集,重复的只记一遍
            # print(vocabSet)
            vocabList = list(vocabSet)
        # print(len(vocabList))
        return vocabList
    
    '''
    vocabList:词汇表
    inputSet:当前样本(话,包含多个已被分割的单词)
    returnVec:返回每个样本(话)所对应的结果向量
    '''
    def setofwords2Vec(vocabList, inputSet):
        returnVec = [0] * len(vocabList)    # 创建词汇表大小的零向量
        for word in inputSet:   # 遍历当前样本(话)中的每一个单词
            if word in vocabList:
                returnVec[vocabList.index(word)] += 1
            else:
                print(f'{word} is not in my vocabulary!')
        return returnVec
    
    '''
    生成训练向量集
    dataSet:训练集
    vocabList:词汇表
    trainMat:返回整个训练集的结果向量集
            (n*m维,n表示样本数,m表示词汇表中词的个数)
    '''
    def get_trainMat(dataSet, vocabList):
        trainMat = []   # 初始化向量列表
        for inputSet in dataSet:    # 遍历训练集中每句话(所有的单词)
            returnVec = setofwords2Vec(vocabList, inputSet)  # 将当前词条向量化
            trainMat.append(returnVec)
        return trainMat
    
    '''
    拉普拉斯平滑朴素贝叶斯分类器训练函数
    要计算多个概率的乘积以获取文档属于哪个类别,如果其中一个概率为0,则最终计算结果为0,显然是不合理的。
    因此使分子初始化为1,分母初始化为2,这种做法就叫做拉普拉斯平滑,又被称为加一平滑。它就是为了解决0概率问题
    trainMat:训练结果向量集
    classVec:每个训练样本的结果向量
    '''
    def trainNB(trainMat, classVec):
        trainNum = len(trainMat)   # 计算训练集的数目(总文档数)
        ClassNum = len(trainMat[0])    # 计算训练集中每一条的大小(总单词数)
    
        p0Num = np.ones(ClassNum)  # 非侮辱类每个单词词频初始化为0,为了防止出现0而初始化为1
        p1Num = np.ones(ClassNum)  # 侮辱类每个单词词频初始化为0,为了防止出现0而初始化为1
        p0Denom = 2  # 非侮辱类所有单词的词频,同理初始化为2
        p1Denom = 2  # 侮辱类所有单词的词频
        num0 = 0    # 各类训练集个数
        num1 = 0    # 同上
    
        pNumList = [p0Num, p1Num]
        pDenomList = [p0Denom, p1Denom]
        numList = [num0, num1]
    
        for i in range(trainNum):  # 遍历每一个训练样本
            for j in range(2):  # 遍历每个类别
                if classVec[i] == j:    # 如果第i个训练样本为j类样本
                    pNumList[j] += trainMat[i]    # 在该样本出现的所有单词词频+1
                    pDenomList[j] += sum(trainMat[i])     # 同理对分母增加的此样本所有单词词频
                    numList[j] += 1  # 该类文档数目加1
    
        # 取log对数仍然是拉普拉斯平滑原理
        pVect, pNum = [], []
        for index in range(2):
            pVect.append(np.log(pNumList[index] / pDenomList[index]))
            pNum.append(numList[index] / float(trainNum))
        return pVect, pNum    # 返回属于非侮辱类、侮辱类和整个训练样本属于侮辱类的概率
    
    '''
    测试朴素贝叶斯分类器
    vec2Classify:向量化的测试样本
    '''
    def classifyNB(vec2Classify, pVect, pNum):
        # 计算公式  log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
        vpl = []  # 文档分类到各类的概率
        for x in range(2):
            vpl.append(sum(vec2Classify * pVect[x]) + np.log(pNum[x]))
    
        reslist = ['非侮辱类', '侮辱类']
        index = [vpl.index(res) for res in vpl if res == max(vpl)]
        return reslist[index[0]]    # 返回分类值
    
    '''
    朴素贝叶斯测试函数
    '''
    def testingNB(testVec):
        dataSet, classVec = loadDataSet()       # 创建实验样本
        vocabList = createVocabList(dataSet)    # 创建词汇表
        trainMat = get_trainMat(dataSet, vocabList)    # 将训练样本向量化
        pVect, vpl = trainNB(trainMat, classVec)    # 训练朴素贝叶斯分类器
    
        thisone = setofwords2Vec(vocabList, testVec)   # 测试样本向量化
        return classifyNB(thisone, pVect, vpl)
    
    if __name__  == '__main__':
        # 测试样本1
        testVec1 = ['love', 'my', 'dalmation']
        print('分类结果是:', testingNB(testVec1))
    
        # 测试样本2
        testVec2 = ['stupid', 'garbage']
        print('分类结果是:', testingNB(testVec2))

    步骤总结

    • 1. 收集数据并预处理
      针对本例来说,省略了收集数据和预处理的大多数步骤。若无则应对训练集文件夹内的文件读取,并去掉多余的符号(若有停用词则删去对应的词),最后采用分词如jieba进行切分,然后进行下一步骤。
    • 2. 向量化处理
      将得到的训练集(和测试集)列表构建不重复的单词集合,然后向量化每一个样本列表,构建训练数据的向量集。
    • 3. 训练模型
      利用贝叶斯公式计算对应的词频进行相应概率计算,注意可能出现0概率现象,因此需要拉普拉斯平滑处理,即特殊初始化操作。
    • 4. 测试验证模型
      将测试数据同样进行向量化处理,然后计算每类概率情况,取概率最大值分类即为预测的类别。本例样本少不再进行验证准确性。

    朴素贝叶斯分类调用(sklearn)

    '''以上涉及获取数据、求词汇表、求训练数据集等方法省略,即替代方法trainNB、classifyNB'''
    
    from sklearn.naive_bayes import GaussianNB
    from sklearn.naive_bayes import MultinomialNB
    from sklearn.naive_bayes import BernoulliNB
    
    '''调用sklearn'''
    def sklearnTest(testVec, testDoc):
        # 重复步骤
        dataSet, classVec = loadDataSet()
        vocabList = createVocabList(dataSet)
        trainMat = get_trainMat(dataSet, vocabList)
        testVec = setofwords2Vec(vocabList, testVec)
    
        X = np.array(trainMat)
        Y = np.array(classVec)
        testVec = np.array(testVec)
    
        if testDoc == 'GaussianNB':  # 高斯朴素贝叶斯
           clf = GaussianNB()
        elif testDoc == 'MultinomialNB':    # 多项分布贝叶斯
            clf = MultinomialNB()
        elif testDoc == 'BernoulliNB':  # 伯努利分布贝叶斯
            clf = BernoulliNB()
        clf.fit(X, Y)
    
        # 测试
        input = [testVec]
        index = clf.predict(input)
        resList = ['非侮辱类', '侮辱类']
        return resList[index[0]]
    
    if __name__  == '__main__':
        # 测试样本1
        testVec1 = ['love', 'my', 'dalmation']
        print('普通朴素贝叶斯分类结果是:', testingNB(testVec1))
        print('高斯朴素贝叶斯分类结果是:', sklearnTest(testVec1, 'GaussianNB'))
        print('多项朴素贝叶斯分类结果是:', sklearnTest(testVec1, 'MultinomialNB'))
        print('伯努利朴素贝叶斯分类结果是:', sklearnTest(testVec1, 'BernoulliNB'))
    
        # 测试样本2
        testVec2 = ['stupid', 'garbage']
        print('普通朴素贝叶斯分类结果是:', testingNB(testVec2))
        print('高斯朴素贝叶斯分类结果是:', sklearnTest(testVec2, 'GaussianNB'))
        print('多项朴素贝叶斯分类结果是:', sklearnTest(testVec2, 'MultinomialNB'))
        print('伯努利朴素贝叶斯分类结果是:', sklearnTest(testVec2, 'BernoulliNB'))
    运行结果

    参考:朴素贝叶斯算法一步步教你轻松学朴素贝叶斯模型算法Sklearn深度篇3

    展开全文
  • 算法完成目标: 这些数据与葡萄牙银行机构的营销活动相关。这些营销活动以电话为基础,一般,银行的客服人员需要联系客户至少一次,以此确认客户是否将认购该银行的产品(定期存款)。我们的目的是预测研究客户定期...

    数据来源:

    选自UCI机器学习库中的「银行营销数据集(Bank Marketing Data Set)」
    

    算法完成目标:

     这些数据与葡萄牙银行机构的营销活动相关。这些营销活动以电话为基础,一般,银行的客服人员需要联系客户至少一次,以此确认客户是否将认购该银行的产品(定期存款)。我们的目的是预测研究客户定期存款业务的概率,可能性。
    

    代码输出的示例:

    ID表示客户唯一标识,pred表示预测客户订购定期存款业务的概率。
    
    ID Pred
    25318 0.123456
    25319 0.654321
    25320 0.799212

    代码中的主要思路:

    首先对数据进行预处理,将数据进行分割,进行归一化处理,将数据划分为训练集和测试集,
    在数据中将“'job','marital','education','default','housing','loan',
    'contact','poutcome','month'”的字符型数据进行编码,然后运用K近邻的方法
    建立模型,然后完成对数据的预测分析。
    
    {
     "cells": [
      {
       "cell_type": "code",
       "execution_count": 3,
       "metadata": {},
       "outputs": [
        {
         "ename": "FileNotFoundError",
         "evalue": "[Errno 2] No such file or directory: './model/encoder0.pkl'",
         "output_type": "error",
         "traceback": [
          "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
          "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
          "\u001b[0;32m<ipython-input-3-4e2fb6df1a4a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     92\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m__name__\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'__main__'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     93\u001b[0m     \u001b[0;31m# train()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 94\u001b[0;31m     \u001b[0mloader\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mModel_Loader\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     95\u001b[0m     \u001b[0mpredict\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mloader\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfetch_predict_value\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     96\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
          "\u001b[0;32m<ipython-input-3-4e2fb6df1a4a>\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     54\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencoder_list\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     55\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m9\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 56\u001b[0;31m            \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencoder_list\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjoblib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'./model/encoder'\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;34m'.pkl'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     57\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjoblib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'./model/ss.pkl'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     58\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0malgo\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjoblib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'./model/svm.pkl'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
          "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/sklearn/externals/joblib/numpy_pickle.py\u001b[0m in \u001b[0;36mload\u001b[0;34m(filename, mmap_mode)\u001b[0m\n\u001b[1;32m    568\u001b[0m             \u001b[0mobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_unpickle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    569\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 570\u001b[0;31m         \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'rb'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    571\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0m_read_fileobject\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfilename\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmmap_mode\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mfobj\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    572\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_basestring\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
          "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: './model/encoder0.pkl'"
         ]
        }
       ],
       "source": [
        "from sklearn.svm import SVC\n",
        "import pandas as pd\n",
        "from sklearn.preprocessing import StandardScaler,LabelEncoder\n",
        "from sklearn.model_selection import train_test_split\n",
        "import numpy as np\n",
        "from sklearn.externals import joblib\n",
        "\n",
        "#设定随机种子 防止模型效果不稳定\n",
        "np.random.seed(50)\n",
        "def train():\n",
        "    #1.加载数据\n",
        "    path='.//train_set.csv'\n",
        "    reader = pd.read_csv(path, sep=',',iterator=True,engine='python')\n",
        "    df = reader.get_chunk(25318)\n",
        "\n",
        "    #2.数据处理\n",
        "    #对数据进行分割处理 划分x,y\n",
        "    X=df.iloc[:,1:-1]\n",
        "    Y=df.iloc[:,-1]\n",
        "    # print(Y.shape)\n",
        "\n",
        "    # 3.特征工程\n",
        "    #对x 中的字符型数据进行编码 变成数值型数据 1,2,3,....\n",
        "    encoder=LabelEncoder()\n",
        "    X_list=['job','marital','education','default','housing','loan','contact','poutcome','month']\n",
        "    for index,e in enumerate(X_list):\n",
        "        X[e] = encoder.fit_transform(X[e])   #对每一个属性列进行操作\n",
        "        joblib.dump(encoder, './model/encoder'+str(index)+'.pkl')   #将每次的参数保存\n",
        "    #对各行文本进行归一化\n",
        "    ss=StandardScaler()  #将每列数据归一化\n",
        "    X=ss.fit_transform(X)\n",
        "\n",
        "    #划分训练集和测试集\n",
        "    x_train,x_test,y_train,y_test=train_test_split(X,Y,test_size=0.2)  #测试集占比0.2\n",
        "\n",
        "    #构建模型\n",
        "    svm=SVC(kernel='rbf',gamma=0.16,C=1.68,probability=True)  #不断调参 得出的参数\n",
        "    svm.fit(x_train,y_train)\n",
        "\n",
        "    #查看模型效果\n",
        "    print('测试集分类效果:{}'.format(svm.score(x_test,y_test)))\n",
        "    print('训练集分类效果:{}'.format(svm.score(x_train,y_train)))\n",
        "\n",
        "    print(\"测试集每个客户的概率{}\".format(svm.predict_proba(x_test)))\n",
        "    #模型持久化\n",
        "    joblib.dump(ss, './model/ss.pkl')  #保存模型参数\n",
        "    joblib.dump(svm, './model/svm.pkl')\n",
        "\n",
        "\n",
        "#建立加载模型函数\n",
        "class Model_Loader(object):\n",
        "    def __init__(self):\n",
        "        # 1. 加载恢复模型\n",
        "        self.encoder_list=[]\n",
        "        for i in range(9):\n",
        "           self.encoder_list.append(joblib.load('./model/encoder'+str(i)+'.pkl'))\n",
        "        self.ss = joblib.load('./model/ss.pkl')\n",
        "        self.algo = joblib.load('./model/svm.pkl')\n",
        "    def fetch_predict_value(self):\n",
        "        #导入预测数据\n",
        "        path1='.//test_set.csv'\n",
        "        reader = pd.read_csv(path1, sep=',', iterator=True, engine='python')\n",
        "        df = reader.get_chunk(10000)\n",
        "        x_test = df.iloc[:, 1:]\n",
        "        #下面是对每个列属性的数据进行数值化操作\n",
        "        # X_list = ['job', 'marital', 'education', 'default', 'housing', 'loan', 'contact', 'poutcome', 'month']\n",
        "        x_test['job']=self.encoder_list[0].transform(x_test['job'])\n",
        "        x_test['marital']=self.encoder_list[1].transform(x_test['marital'])\n",
        "        x_test['education']=self.encoder_list[2].transform(x_test['education'])\n",
        "        x_test['default']=self.encoder_list[3].transform(x_test['default'])\n",
        "        x_test['housing']=self.encoder_list[4].transform(x_test['housing'])\n",
        "        x_test['loan']=self.encoder_list[5].transform(x_test['loan'])\n",
        "        x_test['contact']=self.encoder_list[6].transform(x_test['contact'])\n",
        "        x_test['poutcome']=self.encoder_list[7].transform(x_test['poutcome'])\n",
        "        x_test['month'] = self.encoder_list[8].transform(x_test['month'])\n",
        "\n",
        "        #将每一个属性列进行归一化操作\n",
        "        x_test=self.ss.transform(x_test)\n",
        "        #预测数据\n",
        "        predict_proba=self.algo.predict_proba(x_test)\n",
        "        _predict_proba=[]\n",
        "        #将每个预测为成功的概率取出\n",
        "        for i in predict_proba:\n",
        "            _predict_proba.append(i[1])\n",
        "        #将x_test的ID值与x_test的预测值拼接在一起\n",
        "        x_predict=pd.concat([df.iloc[:,0],pd.DataFrame(_predict_proba)],axis=1)\n",
        "        return x_predict\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    # train()\n",
        "    loader=Model_Loader()\n",
        "    predict=loader.fetch_predict_value()\n",
        "    \n",
        "    test=pd.DataFrame(data =predict)\n",
        "    test.to_csv('F:/test2.csv')\n",
        "    print(predict)\n"
       ]
      },
      {
       "cell_type": "code",
       "execution_count": null,
       "metadata": {},
       "outputs": [],
       "source": []
      }
     ],
     "metadata": {
      "kernelspec": {
       "display_name": "Python 3",
       "language": "python",
       "name": "python3"
      },
      "language_info": {
       "codemirror_mode": {
        "name": "ipython",
        "version": 3
       },
       "file_extension": ".py",
       "mimetype": "text/x-python",
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
       "version": "3.7.0"
      }
     },
     "nbformat": 4,
     "nbformat_minor": 2
    }
    
    
    展开全文
  • 分类算法

    2018-10-20 08:36:16
    分类算法 k近邻算法 通过样本距离进行分类,取最近邻的k个数据 数据集需要标准化 朴素贝叶斯算法 在特征独立的情况下进行分类 算法:P(C∣W)=P(W∣C)P(C)P(W)P(C|W) = \frac{P(W|C)P(C)}{P(W)}P(C∣W)=P(W)P(W∣C)P...
  • 朴素贝叶斯算法
  • 上一篇文章介绍了朴素贝叶斯算法的基本思想,这里主要讲解一下在Hadoop中运用朴素贝叶斯算法进行文档分类的思路。 一、贝叶斯原理 贝叶斯分类算法的理论基于贝叶斯公式,P(B|A)=(P(A|B)P(B))/P(A) ,其中P(A|B)称为...
  • 摘自:http://www.cnblogs.com/zhangchaoyang/articles/2162393.html
  • 分类算法之朴素贝叶斯分类 —-(Naive Bayesian classification) 1.1、简述 贝叶斯分类是一类分类算法的总称,这类算法均以贝叶斯定理为基础,故统称为贝叶斯分类。本文作为分类算法的第一篇,将首先介绍分类问题...
  • 本文利用 scikit-learn 里的朴素贝叶斯算法文档进行分类,以便更深入地理解贝叶斯算法。本文的侧重点不是自然语言处理,所以语料库直接使用英文,以避免介绍中文分词技术。为了读者更好的理解原理,本文介绍了 TF-...
  • 1 /**2 * Author: Orisun3 * Date: Sep 3, 20114 * FileName: FeatureSelect.java5 * Function: 读取word-doc矩阵,计算每个词的信息增益值,排序。输出IG最大的前300个特征项。6 */7 8 importjava.io....
  • 机器学习的一个重要应用就是文档的自动分类。...朴素贝叶斯是贝叶斯分类器的一个扩展,是用于文档分类的常用算法。 朴素贝叶斯算法大致步骤 收集数据:可以使用任何方法。如RSS源。 准备数据:数值型或布尔型数...
  • 1.复旦语料库train集中有6个类是多于1000个文档的,把它们取出来,分别删减至1000个文档,构成接下来我们要进行实验的训练集。 2.执行Predeal.java,它依次进行三项操作:把文件重命名为顺序的数字编号;把文件编号...
  • 文档包含了大数据逻辑回归分类算法 算法+源码+详细步骤
  • 在本文中,我们介绍了一种称为文本文档中最高单词重复率的新算法(HRWiTD),以对自动阿拉伯文本进行分类。 语料库分为训练集和测试集,以应用于建议的分类技术。 分析训练集以进行学习,并将学习数据存储在“学习...
  • Python基于sklearn库的分类算法简单应用示例来源:中文源码网浏览: 次日期:2018年9月2日【下载文档:Python基于sklearn库的分类算法简单应用示例.txt】(友情提示:右键点上行txt文档名->目标另存为)Python基于...
  • 朴素贝叶斯预测分类的思想就是根据待预测文档的特征(TF-IDF高的词)...朴素贝叶斯进行文档分类的简单案例:     demo.py(朴素贝叶斯算法实例,预测新闻类别): from sklearn.datasets import fetch_20...
  • 本文接数据挖掘-基于贝叶斯算法及KNN算法的newsgroup18828文档分类器的JAVA实现(上)本分类器的完整工程可以到点击打开链接下载,详细说明的运行方法,用eclipse可以运行,学习数据挖掘的朋友可以跑一下,有问题...
  • 本文主要描述基于贝叶斯算法及KNN算法的newsgroup18828文档分类器的设计及实现,包括数据预处理、贝叶斯算法及KNN算法实现。本分类器的完整工程可以到点击打开链接下载,详细说明的运行方法,用eclipse可以运行,...
  • 为了快速准确地对文档进行分类,提出了一种基于局部鉴别嵌入LDE和简化SVM的高效文档分类算法。该算法首先利用LDE算法把高维文档数据投影到低维特征空间,然后在低维特征空间利用精简SVM进行分类。实验结果表明该算法...
  • 建立原始文档 ~/corpus/C1下建三个文件:0,1,2。内容分别为: 0 眼睛 明亮 健康 身体 发达 1 高大 身材 胳膊 勇猛 四肢 2 胳膊 健康 身体 高大 健康 ~/...
  • 相比《机器学习算法(13)python实现应用机器学习于情感分析-训练文档分类》将采用一种被称为“核外学习”的技术, 这种技术可以通过对数据集的小批增量来模拟分类器完成大型数据集的处理工作。 import pandas as pd...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,832
精华内容 732
关键字:

文档分类算法