精华内容
下载资源
问答
  • 贝叶斯方法优缺点

    万次阅读 2018-08-29 22:16:33
    恩,此节作为更贴近实际应用的部分,将介绍贝叶斯方法优缺点、常见适用场景和可优化点,然后找点实际场景撸点例子练练手,看看工具怎么用。 PS:本文所有的python代码和ipython notebook已整理至 github相应...

    viewmode=contents” rel=”nofollow” target=”_blank”>寒小阳 && 龙心尘
    时间:2016年2月。
    出处:http://blog.csdn.net/han_xiaoyang/article/details/50629608
    http://blog.csdn.net/longxinchen_ml/article/details/50629613
    声明:版权所有,转载请联系作者并注明出处

    1.引言

    前两篇博文介绍了朴素贝叶斯这个名字读着”萌蠢”但实际上简单直接高效的方法,我们也介绍了一下贝叶斯方法的一些细节。按照老规矩,『锄头』给你了,得负责教教怎么用和注意事项,也顺便带大家去除除草对吧。恩,此节作为更贴近实际应用的部分,将介绍贝叶斯方法的优缺点、常见适用场景和可优化点,然后找点实际场景撸点例子练练手,看看工具怎么用。

    PS:本文所有的python代码和ipython notebook已整理至github相应页面,欢迎下载和尝试。

    2.贝叶斯方法优缺点

    既然讲的是朴素贝叶斯,那博主保持和它一致的风格,简单直接高效地丢干货了:

    • 优点
    1. 对待预测样本进行预测,过程简单速度快(想想邮件分类的问题,预测就是分词后进行概率乘积,在log域直接做加法更快)。
    2. 对于多分类问题也同样很有效,复杂度也不会有大程度上升。
    3. 在分布独立这个假设成立的情况下,贝叶斯分类器效果奇好,会略胜于逻辑回归,同时我们需要的样本量也更少一点
    4. 对于类别类的输入特征变量,效果非常好。对于数值型变量特征,我们是默认它符合正态分布的。
    • 缺点
    1. 对于测试集中的一个类别变量特征,如果在训练集里没见过,直接算的话概率就是0了,预测功能就失效了。当然,我们前面的文章提过我们有一种技术叫做『平滑』操作,可以缓解这个问题,最常见的平滑技术是拉普拉斯估测。
    2. 那个…咳咳,朴素贝叶斯算出的概率结果,比较大小还凑合,实际物理含义…恩,别太当真。
    3. 朴素贝叶斯有分布独立的假设前提,而现实生活中这些predictor很难是完全独立的

    3.最常见应用场景

    • 文本分类/垃圾文本过滤/情感判别:这大概会朴素贝叶斯应用做多的地方了,即使在现在这种分类器层出不穷的年代,在文本分类场景中,朴素贝叶斯依旧坚挺地占据着一席之地。原因嘛,大家知道的,因为多分类很简单,同时在文本数据中,分布独立这个假设基本是成立的。而垃圾文本过滤(比如垃圾邮件识别)和情感分析(微博上的褒贬情绪)用朴素贝叶斯也通常能取得很好的效果。
    • 多分类实时预测:这个是不是不能叫做场景?对于文本相关的多分类实时预测,它因为上面提到的优点,被广泛应用,简单又高效。
    • 推荐系统:是的,你没听错,是用在推荐系统里!!朴素贝叶斯和协同过滤(Collaborative Filtering)是一对好搭档,协同过滤是强相关性,但是泛化能力略弱,朴素贝叶斯和协同过滤一起,能增强推荐的覆盖度和效果。

    4.朴素贝叶斯注意点

    这个部分的内容,本来应该在最后说的,不过为了把干货集中放在代码示例之前,先搁这儿了,大家也可以看完朴素贝叶斯的各种例子之后,回来再看看这些tips。

    • 大家也知道,很多特征是连续数值型的,但是它们不一定服从正态分布,一定要想办法把它们变换调整成满足正态分布!!
    • 对测试数据中的0频次项,一定要记得平滑,简单一点可以用『拉普拉斯平滑』。
    • 先处理处理特征,把相关特征去掉,因为高相关度的2个特征在模型中相当于发挥了2次作用。
    • 朴素贝叶斯分类器一般可调参数比较少,比如scikit-learn中的朴素贝叶斯只有拉普拉斯平滑因子alpha,类别先验概率class_prior和预算数据类别先验fit_prior。模型端可做的事情不如其他模型多,因此我们还是集中精力进行数据的预处理,以及特征的选择吧。
    • 那个,一般其他的模型(像logistic regression,SVM等)做完之后,我们都可以尝试一下bagging和boosting等融合增强方法。咳咳,很可惜,对朴素贝叶斯里这些方法都没啥用。原因?原因是这些融合方法本质上是减少过拟合,减少variance的。朴素贝叶斯是没有variance可以减小。

    5. 朴素贝叶斯训练/建模

    理论干货和注意点都说完了,来提提怎么快速用朴素贝叶斯训练模型吧。博主一直提倡要站在巨人的肩膀上编程(其实就是懒…同时一直很担忧写出来的代码的健壮性…),咳咳,我们又很自然地把scikit-learn拿过来了。scikit-learn里面有3种不同类型的朴素贝叶斯:

    • 高斯分布型:用于classification问题,假定属性/特征是服从正态分布的。
    • 多项式型:用于离散值模型里。比如文本分类问题里面我们提到过,我们不光看词语是否在文本中出现,也得看出现的次数。如果总词数为n,出现词数为m的话,说起来有点像掷骰子n次出现m次这个词的场景。
    • 伯努利型:这种情况下,就如之前博文里提到的bag of words处理方式一样,最后得到的特征只有0(没出现)和1(出现过)。

    根据你的数据集,可以选择scikit-learn中以上任意一种朴素贝叶斯,我们直接举个简单的例子,用高斯分布型朴素贝叶斯建模:

    # 我们直接取iris数据集,这个数据集有名到都不想介绍了...
    # 其实就是根据花的各种数据特征,判定是什么花
    from sklearn import datasets
    iris = datasets.load_iris()
    iris.data[:5]
    #array([[ 5.1,  3.5,  1.4,  0.2],
    #       [ 4.9,  3. ,  1.4,  0.2],
    #       [ 4.7,  3.2,  1.3,  0.2],
    #       [ 4.6,  3.1,  1.5,  0.2],
    #       [ 5. ,  3.6,  1.4,  0.2]])
    
    #我们假定sepal length, sepal width, petal length, petal width 4个量独立且服从高斯分布,用贝叶斯分类器建模
    from sklearn.naive_bayes import GaussianNB
    gnb = GaussianNB()
    y_pred = gnb.fit(iris.data, iris.target).predict(iris.data)
    right_num = (iris.target == y_pred).sum()
    print("Total testing num :%d , naive bayes accuracy :%f" %(iris.data.shape[0], float(right_num)/iris.data.shape[0]))
    # Total testing num :150 , naive bayes accuracy :0.960000
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    你看,朴素贝叶斯分类器,简单直接高效,在150个测试样本上,准确率为96%。

    6.朴素贝叶斯之文本主题分类器

    这是朴素贝叶斯最擅长的应用场景之一,对于不同主题的文本,我们可以用朴素贝叶斯训练一个分类器,然后将其应用在新数据上,预测主题类型。

    6.1 新闻数据分类

    我们使用搜狐新闻数据来实验朴素贝叶斯分类器,这部分新闻数据包括it、汽车、财经、健康等9个类别,简洁版数据解压缩后总共16289条新闻,一篇新闻一个txt,我们把数据合并到一个大文件中,一行一篇文章,同时将新闻id(指明新闻的类别)放在文章之前,然后用ICTCLAS(python的话你也可以用结巴分词)进行分词,得到以下的文本内容:


    分词后内容

    我们随机选取3/5的数据作为训练集,2/5的数据作为测试集,采用互信息对文本特征进行提取,提取出1000个左右的特征词。然后用朴素贝叶斯分类器进行训练,实际训练过程就是对于特征词,统计在训练集和各个类别出现的次数,测试阶段做预测也是扫描一遍测试集,计算相应的概率。因此整个过程非常高效,完整的运行代码如下:

    # 这部分代码基本纯手撸的...没有调用开源库...大家看看就好...
    #!encoding=utf-8
    import sys, math, random, collections
    
    def shuffle(inFile):
        '''
            简单的乱序操作,用于生成训练集和测试集
        '''
        textLines = [line.strip() for line in open(inFile)]
        print "正在准备训练和测试数据,请稍后..."
        random.shuffle(textLines)
        num = len(textLines)
        trainText = textLines[:3*num/5]
        testText = textLines[3*num/5:]
        print "准备训练和测试数据准备完毕,下一步..."
        return trainText, testText
    
    #总共有9种新闻类别,我们给每个类别一个编号
    lables = ['A','B','C','D','E','F','G','H','I']
    def lable2id(lable):
        for i in xrange(len(lables)):
            if lable == lables[i]:
                return i
        raise Exception('Error lable %s' % (lable))
    
    def doc_dict():
        '''
            构造和类别数等长的0向量
        '''
        return [0]*len(lables)
    
    def mutual_info(N,Nij,Ni_,N_j):
        '''
            计算互信息,这里log的底取为2
        '''
        return Nij * 1.0 / N * math.log(N * (Nij+1)*1.0/(Ni_*N_j))/ math.log(2)
    
    def count_for_cates(trainText, featureFile):
        '''
            遍历文件,统计每个词在每个类别出现的次数,和每类的文档数
            并写入结果特征文件
        '''
        docCount = [0] * len(lables)
        wordCount = collections.defaultdict(doc_dict())
        #扫描文件和计数  
        for line in trainText:
            lable,text = line.strip().split(' ',1)
            index = lable2id(lable[0])        
            words = text.split(' ')
            for word in words:
                wordCount[word][index] += 1
                docCount[index] += 1
        #计算互信息值
        print "计算互信息,提取关键/特征词中,请稍后..."
        miDict = collections.defaultdict(doc_dict())
        N = sum(docCount)
        for k,vs in wordCount.items():
            for i in xrange(len(vs)):
                N11 = vs[i]
                N10 = sum(vs) - N11
                N01 = docCount[i] - N11
                N00 = N - N11 - N10 - N01
                mi = mutual_info(N,N11,N10+N11,N01+N11) + mutual_info(N,N10,N10+N11,N00+N10)+ mutual_info(N,N01,N01+N11,N01+N00)+ mutual_info(N,N00,N00+N10,N00+N01)
                miDict[k][i] = mi
        fWords = set()
        for i in xrange(len(docCount)):
            keyf = lambda x:x[1][i]
            sortedDict = sorted(miDict.items(),key=keyf,reverse=True)
            for j in xrange(100):
                fWords.add(sortedDict[j][0])
        out = open(featureFile, 'w')
        #输出各个类的文档数目
        out.write(str(docCount)+"\n")
        #输出互信息最高的词作为特征词
        for fword in fWords:
            out.write(fword+"\n")
        print "特征词写入完毕..."
        out.close()
    
    def load_feature_words(featureFile):
        '''
            从特征文件导入特征词
        '''
        f = open(featureFile)
        #各个类的文档数目
        docCounts = eval(f.readline())
        features = set()
        #读取特征词
        for line in f:
            features.add(line.strip())
        f.close()
        return docCounts,features
    
    def train_bayes(featureFile, textFile, modelFile):
        '''
            训练贝叶斯模型,实际上计算每个类中特征词的出现次数
        '''
        print "使用朴素贝叶斯训练中..."
        docCounts,features = load_feature_words(featureFile)
        wordCount = collections.defaultdict(doc_dict())
        #每类文档特征词出现的次数
        tCount = [0]*len(docCounts)
        for line in open(textFile):
            lable,text = line.strip().split(' ',1)
            index = lable2id(lable[0])        
            words = text.split(' ')
            for word in words:
                if word in features:
                    tCount[index] += 1
                    wordCount[word][index] += 1
        outModel = open(modelFile, 'w')
        #拉普拉斯平滑
        print "训练完毕,写入模型..."
        for k,v in wordCount.items():
            scores = [(v[i]+1) * 1.0 / (tCount[i]+len(wordCount)) for i in xrange(len(v))]
            outModel.write(k+"\t"+scores+"\n")
        outModel.close()
    
    def load_model(modelFile):
        '''
            从模型文件中导入计算好的贝叶斯模型
        '''
        print "加载模型中..."
        f = open(modelFile)
        scores = {}
        for line in f:
            word,counts = line.strip().rsplit('\t',1)    
            scores[word] = eval(counts)
        f.close()
        return scores
    
    def predict(featureFile, modelFile, testText):
        '''
            预测文档的类标,标准输入每一行为一个文档
        '''
        docCounts,features = load_feature_words()    
        docScores = [math.log(count * 1.0 /sum(docCounts)) for count in docCounts]
        scores = load_model(modelFile)
        rCount = 0
        docCount = 0
        print "正在使用测试数据验证模型效果..."
        for line in testText:
            lable,text = line.strip().split(' ',1)
            index = lable2id(lable[0])        
            words = text.split(' ')
            preValues = list(docScores)
            for word in words:
                if word in features:                
                    for i in xrange(len(preValues)):
                        preValues[i]+=math.log(scores[word][i])
            m = max(preValues)
            pIndex = preValues.index(m)
            if pIndex == index:
                rCount += 1
            #print lable,lables[pIndex],text
            docCount += 1
        print("总共测试文本量: %d , 预测正确的类别量: %d, 朴素贝叶斯分类器准确度:%f" %(rCount,docCount,rCount * 1.0 / docCount))       
    
    
    if __name__=="__main__":
        if len(sys.argv) != 4:
        print "Usage: python naive_bayes_text_classifier.py sougou_news.txt feature_file.out model_file.out"
        sys.exit()
    
        inFile = sys.argv[1]
        featureFile = sys.argv[2]
        modelFile = sys.argv[3]
    
        trainText, testText = shuffle(inFile)
        count_for_cates(trainText, featureFile)
        train_bayes(featureFile, trainText, modelFile)
        predict(featureFile, modelFile, testText)
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172

    6.2 分类结果

    运行结果如下,在6515条数据上,9个类别的新闻上,有84.1%的准确度:


    朴素贝叶斯分类器结果

    7. Kaggle比赛之『旧金山犯罪分类预测』

    7.1 旧金山犯罪分类预测问题

    没过瘾对吧,确实每次学完一个机器学习算法,不在实际数据上倒腾倒腾,总感觉不那么踏实(想起来高中各种理科科目都要找点题来做的感觉)。好,我们继续去Kaggle扒点场景和数据来练练手。正巧之前Kaggle上有一个分类问题,场景和数据也都比较简单,我们拿来用朴素贝叶斯试试水。问题请戳这里

    7.2 背景介绍

    我们大致介绍一下,说的是『水深火热』的大米国,在旧金山这个地方,一度犯罪率还挺高的,然后很多人都经历过大到暴力案件,小到东西被偷,车被划的事情。当地警方也是努力地去总结和想办法降低犯罪率,一个挑战是在给出犯罪的地点和时间的之后,要第一时间确定这可能是一个什么样的犯罪类型,以确定警力等等。后来干脆一不做二不休,直接把12年内旧金山城内的犯罪报告都丢带Kaggle上,说『大家折腾折腾吧,看看谁能帮忙第一时间预测一下犯罪类型』。犯罪报告里面包括日期描述星期几所属警区处理结果地址GPS定位等信息。当然,分类问题有很多分类器可以选择,我们既然刚讲过朴素贝叶斯,刚好就拿来练练手好了。

    7.3 数据一瞥

    数据可以在Kaggle比赛数据页面下载到,大家也可以在博主提供的百度网盘地址中下载到。我们依旧用pandas载入数据,先看看数据内容。

    import pandas as pd
    import numpy as np
    
    #用pandas载入csv训练数据,并解析第一列为日期格式
    train=pd.read_csv('/Users/Hanxiaoyang/sf_crime_data/train.csv', parse_dates = ['Dates'])
    test=pd.read_csv('/Users/Hanxiaoyang/sf_crime_data/test.csv', parse_dates = ['Dates'])
    train
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    得到如下的结果:


    旧金山犯罪类型图

    我们依次解释一下每一列的含义:

    • Date: 日期
    • Category: 犯罪类型,比如 Larceny/盗窃罪 等.
    • Descript: 对于犯罪更详细的描述
    • DayOfWeek: 星期几
    • PdDistrict: 所属警区
    • Resolution: 处理结果,比如说『逮捕』『逃了』
    • Address: 发生街区位置
    • X and Y: GPS坐标

    train.csv中的数据时间跨度为12年,包含了90w+的记录。另外,这部分数据,大家从上图上也可以看出来,大部分都是『类别』型,比如犯罪类型,比如星期几。

    7.4 特征预处理

    上述数据中类别和文本型非常多,我们要进行特征预处理,对于特征预处理的部分,我们在前面的博文机器学习系列(3)逻辑回归应用之Kaggle泰坦尼克之灾机器学习系列(6)从白富美相亲看特征预处理与选择(下)都有较细的介绍。对于类别特征,我们用最常见的因子化操作将其转成数值型,比如我们把犯罪类型用因子化进行encode,也就是说生成如下的向量:

    星期一/Monday = 1,0,0,0,...
    星期二/Tuesday = 0,1,0,0,...
    星期三/Wednesday = 0,0,1,0,...
    ...
     
    • 1
    • 2
    • 3
    • 4

    我们之前也提到过,用pandas的get_dummies()可以直接拿到这样的一个二值化的01向量。Pandas里面还有一个很有用的方法LabelEncoder可以用于对类别编号。对于已有的数据特征,我们打算做下面的粗略变换:

    • 用LabelEncoder**对犯罪类型做编号**;
    • 处理时间,在我看来,也许犯罪发生的时间点(小时)是非常重要的,因此我们会用Pandas把这部分数据抽出来;
    • 街区星期几时间点用get_dummies()因子化;
    • 做一些组合特征,比如把上述三个feature拼在一起,再因子化一下;

    具体的数据和特征处理如下:

    import pandas as pd
    import numpy as np
    from sklearn.cross_validation import train_test_split
    from sklearn import preprocessing
    
    #用LabelEncoder对不同的犯罪类型编号
    leCrime = preprocessing.LabelEncoder()
    crime = leCrime.fit_transform(train.Category)
    
    #因子化星期几,街区,小时等特征
    days = pd.get_dummies(train.DayOfWeek)
    district = pd.get_dummies(train.PdDistrict)
    hour = train.Dates.dt.hour
    hour = pd.get_dummies(hour) 
    
    #组合特征
    trainData = pd.concat([hour, days, district], axis=1)
    trainData['crime']=crime
    
    #对于测试数据做同样的处理
    days = pd.get_dummies(test.DayOfWeek)
    district = pd.get_dummies(test.PdDistrict)
    
    hour = test.Dates.dt.hour
    hour = pd.get_dummies(hour) 
    
    testData = pd.concat([hour, days, district], axis=1)
    trainData
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    然后可以看到特征处理后的数据如下所示:
    特征处理之后

    7.5 朴素贝叶斯 VS 逻辑回归

    拿到初步的特征了,下一步就可以开始建模了。

    因为之前的博客机器学习系列(1)逻辑回归初步机器学习系列(2)从初等数学视角解读逻辑回归机器学习系列(3)_逻辑回归应用之Kaggle泰坦尼克之灾中提到过逻辑回归这种分类算法,我们这里打算一并拿来建模,做个比较。
    还需要提到的一点是,大家参加Kaggle的比赛,一定要注意最后排名和评定好坏用的标准,比如说在现在这个多分类问题中,Kaggle的评定标准并不是precision,而是multi-class log_loss,这个值越小,表示最后的效果越好。

    我们可以快速地筛出一部分重要的特征,搭建一个baseline系统,再考虑步步优化。比如我们这里简单一点,就只取星期几街区作为分类器输入特征,我们用scikit-learn中的train_test_split函数拿到训练集和交叉验证集,用朴素贝叶斯和逻辑回归都建立模型,对比一下它们的表现:

    ffrom sklearn.cross_validation import train_test_split
    from sklearn import preprocessing
    from sklearn.metrics import log_loss
    from sklearn.naive_bayes import BernoulliNB
    from sklearn.linear_model import LogisticRegression
    import time
    
    # 只取星期几和街区作为分类器输入特征
    features = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday', 'BAYVIEW', 'CENTRAL', 'INGLESIDE', 'MISSION',
     'NORTHERN', 'PARK', 'RICHMOND', 'SOUTHERN', 'TARAVAL', 'TENDERLOIN']
    
    # 分割训练集(3/5)和测试集(2/5)
    training, validation = train_test_split(trainData, train_size=.60)
    
    # 朴素贝叶斯建模,计算log_loss
    model = BernoulliNB()
    nbStart = time.time()
    model.fit(training[features], training['crime'])
    nbCostTime = time.time() - nbStart
    predicted = np.array(model.predict_proba(validation[features]))
    print "朴素贝叶斯建模耗时 %f 秒" %(nbCostTime)
    print "朴素贝叶斯log损失为 %f" %(log_loss(validation['crime'], predicted))
    
    #逻辑回归建模,计算log_loss
    model = LogisticRegression(C=.01)
    lrStart= time.time()
    model.fit(training[features], training['crime'])
    lrCostTime = time.time() - lrStart
    predicted = np.array(model.predict_proba(validation[features]))
    log_loss(validation['crime'], predicted)
    print "逻辑回归建模耗时 %f 秒" %(lrCostTime)
    print "逻辑回归log损失为 %f" %(log_loss(validation['crime'], predicted)) 
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    实验的结果如下:


    nb vs lr

    我们可以看到目前的特征和参数设定下,朴素贝叶斯的log损失还低一些,另外我们可以明显看到,朴素贝叶斯建模消耗的时间0.640398秒远小于逻辑回归建模42.856376秒。

    考虑到犯罪类型可能和犯罪事件发生的小时时间点相关,我们加入小时时间点特征再次建模,代码和结果如下:

    from sklearn.cross_validation import train_test_split
    from sklearn import preprocessing
    from sklearn.metrics import log_loss
    from sklearn.naive_bayes import BernoulliNB
    from sklearn.linear_model import LogisticRegression
    import time
    
    # 添加犯罪的小时时间点作为特征
    features = ['Friday', 'Monday', 'Saturday', 'Sunday', 'Thursday', 'Tuesday',
    'Wednesday', 'BAYVIEW', 'CENTRAL', 'INGLESIDE', 'MISSION',
    'NORTHERN', 'PARK', 'RICHMOND', 'SOUTHERN', 'TARAVAL', 'TENDERLOIN']
    
    hourFea = [x for x in range(0,24)]
    features = features + hourFea
    
    # 分割训练集(3/5)和测试集(2/5)
    training, validation = train_test_split(trainData, train_size=.60)
    
    # 朴素贝叶斯建模,计算log_loss
    model = BernoulliNB()
    nbStart = time.time()
    model.fit(training[features], training['crime'])
    nbCostTime = time.time() - nbStart
    predicted = np.array(model.predict_proba(validation[features]))
    print "朴素贝叶斯建模耗时 %f 秒" %(nbCostTime)
    print "朴素贝叶斯log损失为 %f" %(log_loss(validation['crime'], predicted))
    
    #逻辑回归建模,计算log_loss
    model = LogisticRegression(C=.01)
    lrStart= time.time()
    model.fit(training[features], training['crime'])
    lrCostTime = time.time() - lrStart
    predicted = np.array(model.predict_proba(validation[features]))
    log_loss(validation['crime'], predicted)
    print "逻辑回归建模耗时 %f 秒" %(lrCostTime)
    print "逻辑回归log损失为 %f" %(log_loss(validation['crime'], predicted))
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36


    添加小时时间点后的结果

    可以看到在这三个类别特征下,朴素贝叶斯相对于逻辑回归,依旧有一定的优势(log损失更小),同时训练时间很短,这意味着模型虽然简单,但是效果依旧强大。顺便提一下,朴素贝叶斯1.13s训练出来的模型,预测的效果在Kaggle排行榜上已经能进入Top 35%了,如果进行一些优化,比如特征处理、特征组合等,结果会进一步提高。

    8. Kaggle比赛之影评与观影者情感判定

    博主想了想,既然朴素贝叶斯最常见的应用场景就那么几个,干脆我们都一并覆盖得了。咳咳,对,还有一个非常重要的应用场景是情感分析(尤其是褒贬判定),于是我又上Kaggle溜达了一圈,扒下来一个类似场景的比赛。比赛的名字叫做当词袋/Bag of words 遇上 爆米花/Bags of Popcorn,地址为https://www.kaggle.com/c/word2vec-nlp-tutorial/,有兴趣的同学可以上去瞄一眼。

    8.1 背景介绍

    这个比赛的背景大概是:国外有一个类似豆瓣电影一样的IMDB,也是你看完电影,可以上去打个分,吐个槽的地方。然后大家就在想,有这么多数据,总得折腾点什么吧,于是乎,第一个想到的就是,赞的喷的内容都有了,咱们就来分分类,看看能不能根据内容分布褒贬。PS:很多同学表示,分个褒贬有毛线难的,咳咳,计算机比较笨,另外,语言这种东西,真心是博大精深的,我们随手从豆瓣上抓了几条《功夫熊猫3》影评下来,表示有些虽然我是能看懂,但是不处理直接给计算机看,它应该是一副『什么鬼』的表情。。。


    功夫熊猫3影评

    多说一句,Kaggle原文引导里是用word2vec的方式将词转为词向量,后再用deep learning的方式做的。深度学习好归好,但是毕竟耗时耗力耗资源,我们用最最naive的朴素贝叶斯撸一把,说不定效果也能不错,不试试谁知道呢。另外,朴素贝叶斯建模真心速度快,很多场景下,快速建模快速迭代优化正是我们需要的嘛。

    8.2 数据一瞥

    言归正传,回到Kaggle中这个问题上来,先瞄一眼数据。Kaggle数据页面地址为https://www.kaggle.com/c/word2vec-nlp-tutorial/data,大家也可以到博主的百度网盘中下载。数据包如下图所示:


    Kaggle影评数据页面

    其中包含有情绪标签的训练数据labeledTrainData,没有情绪标签的训练数据unlabeledTrainData,以及测试数据testData。labeledTrainData包括idsentiment和**review**3个部分,分别指代用户id,情感标签,评论内容。

    解压缩labeledTrainData后用vim打开,内容如下:


    训练数据内容

    下面我们读取数据并做一些基本的预处理(比如说把评论部分的html标签去掉等等):

    import re  #正则表达式
    from bs4 import BeautifulSoup  #html标签处理
    import pandas as pd
    
    def review_to_wordlist(review):
        '''
        把IMDB的评论转成词序列
        '''
        # 去掉HTML标签,拿到内容
        review_text = BeautifulSoup(review).get_text()
        # 用正则表达式取出符合规范的部分
        review_text = re.sub("[^a-zA-Z]"," ", review_text)
        # 小写化所有的词,并转成词list
        words = review_text.lower().split()
        # 返回words
        return words
    
    # 使用pandas读入训练和测试csv文件
    train = pd.read_csv('/Users/Hanxiaoyang/IMDB_sentiment_analysis_data/labeledTrainData.tsv', header=0, delimiter="\t", quoting=3)
    test = pd.read_csv('/Users/Hanxiaoyang/IMDB_sentiment_analysis_data/testData.tsv', header=0, delimiter="\t", quoting=3 )
    # 取出情感标签,positive/褒 或者 negative/贬
    y_train = train['sentiment']
    # 将训练和测试数据都转成词list
    train_data = []
    for i in xrange(0,len(train['review'])):
        train_data.append(" ".join(review_to_wordlist(train['review'][i])))
    test_data = []
    for i in xrange(0,len(test['review'])):
        test_data.append(" ".join(review_to_wordlist(test['review'][i])))
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    我们在ipython notebook里面看一眼,发现数据已经格式化了,如下:


    格式化后的数据

    8.3 特征处理

    紧接着又到了头疼的部分了,数据有了,我们得想办法从数据里面拿到有区分度的特征。比如说Kaggle该问题的引导页提供的word2vec就是一种文本到数值域的特征抽取方式,比如说我们在第6小节提到的用互信息提取关键字也是提取特征的一种。比如说在这里,我们打算用在文本检索系统中非常有效的一种特征:TF-IDF(term frequency-interdocument frequency)向量。每一个电影评论最后转化成一个TF-IDF向量。对了,对于TF-IDF不熟悉的同学们,我们稍加解释一下,TF-IDF是一种统计方法,用以评估一字词(或者n-gram)对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随着它在文件中出现的次数成正比增加,但同时会随着它在语料库中出现的频率成反比下降。这是一个能很有效地判定对评论褒贬影响大的词或短语的方法。

    那个…博主打算继续偷懒,把scikit-learn中TFIDF向量化方法直接拿来用,想详细了解的同学可以戳sklearn TFIDF向量类。对了,再多说几句我的处理细节,停用词被我掐掉了,同时我在单词的级别上又拓展到2元语言模型(对这个不了解的同学别着急,后续的博客介绍马上就来),恩,你可以再加3元4元语言模型…博主主要是单机内存不够了,先就2元上,凑活用吧…

    from sklearn.feature_extraction.text import TfidfVectorizer as TFIV
    # 初始化TFIV对象,去停用词,加2元语言模型
    tfv = TFIV(min_df=3,  max_features=None, strip_accents='unicode', analyzer='word',token_pattern=r'\w{1,}', ngram_range=(1, 2), use_idf=1,smooth_idf=1,sublinear_tf=1, stop_words = 'english')
    # 合并训练和测试集以便进行TFIDF向量化操作
    X_all = train_data + test_data
    len_train = len(train_data)
    
    # 这一步有点慢,去喝杯茶刷会儿微博知乎歇会儿...
    tfv.fit(X_all)
    X_all = tfv.transform(X_all)
    # 恢复成训练集和测试集部分
    X = X_all[:len_train] 
    X_test = X_all[len_train:]
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    8.4 朴素贝叶斯 vs 逻辑回归

    特征现在我们拿到手了,该建模了,好吧,博主折腾劲又上来了,那个…咳咳…我们还是朴素贝叶斯和逻辑回归都建个分类器吧,然后也可以比较比较,恩。
    『talk is cheap, I’ll show you the code』,直接放码过来了哈。

    # 多项式朴素贝叶斯
    from sklearn.naive_bayes import MultinomialNB as MNB
    
    model_NB = MNB()
    model_NB.fit(X, y_train) #特征数据直接灌进来
    MNB(alpha=1.0, class_prior=None, fit_prior=True)
    
    from sklearn.cross_validation import cross_val_score
    import numpy as np
    
    print "多项式贝叶斯分类器20折交叉验证得分: ", np.mean(cross_val_score(model_NB, X, y_train, cv=20, scoring='roc_auc'))
    # 多项式贝叶斯分类器20折交叉验证得分: 0.950837239
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    # 折腾一下逻辑回归,恩
    from sklearn.linear_model import LogisticRegression as LR
    from sklearn.grid_search import GridSearchCV
    
    # 设定grid search的参数
    grid_values = {'C':[30]}  
    # 设定打分为roc_auc
    model_LR = GridSearchCV(LR(penalty = 'L2', dual = True, random_state = 0), grid_values, scoring = 'roc_auc', cv = 20) 
    # 数据灌进来
    model_LR.fit(X,y_train)
    # 20折交叉验证,开始漫长的等待...
    GridSearchCV(cv=20, estimator=LogisticRegression(C=1.0, class_weight=None, dual=True, 
                 fit_intercept=True, intercept_scaling=1, penalty='L2', random_state=0, tol=0.0001),
            fit_params={}, iid=True, loss_func=None, n_jobs=1,
            param_grid={'C': [30]}, pre_dispatch='2*n_jobs', refit=True,
            score_func=None, scoring='roc_auc', verbose=0)
    #输出结果
    print model_LR.grid_scores_
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    最后逻辑回归的结果是[mean: 0.96459, std: 0.00489, params: {'C': 30}]

    咳咳…看似逻辑回归在这个问题中,TF-IDF特征下表现要稍强一些…不过同学们自己跑一下就知道,这2个模型的训练时长真心不在一个数量级,逻辑回归在数据量大的情况下,要等到睡着…另外,要提到的一点是,因为我这里只用了2元语言模型(2-gram),加到3-gram和4-gram,最后两者的结果还会提高,而且朴素贝叶斯说不定会提升更快一点,内存够的同学们自己动手试试吧^_^

    9. 总结

    本文为朴素贝叶斯的实践和进阶篇,先丢了点干货,总结了贝叶斯方法的优缺点,应用场景,注意点和一般建模方法。紧接着对它最常见的应用场景,抓了几个例子,又来了一遍手把手系列,不管是对于文本主题分类、多分类问题(犯罪类型分类) 还是 情感分析/分类,朴素贝叶斯都是一个简单直接高效的方法。尤其是在和逻辑回归的对比中可以看出,在这些问题中,朴素贝叶斯能取得和逻辑回归相近的成绩,但是训练速度远快于逻辑回归,真正的直接和高效。



    展开全文
  • 注:马氏距离一定要先给出样本集的统计性质,比如均值向量,协方差矩阵等。关于马氏距离的介绍如下:         KNN算法的优点: 1. 思想简单,理论成熟,既可以用来做分类也可以用来做回归...

    https://www.toutiao.com/a6706432431647359491/

     

     

    2019-06-25 19:43:14

    朴素贝叶斯:

    1. 如果给出的特征向量长度可能不同,这是需要归一化为通长度的向量(这里以文本分类为例),比如说是句子单词的话,则长度为整个词汇量的长度,对应位置是该单词出现的次数。

    2. 计算公式如下:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    其中一项条件概率可以通过朴素贝叶斯条件独立展开。要注意一点就是

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

    的计算方法,而由朴素贝叶斯的前提假设可知,

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

    =

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

    ,因此一般有两种,一种是在类别为ci的那些样本集中,找到wj出现次数的总和,然后除以该样本的总和;第二种方法是类别为ci的那些样本集中,找到wj出现次数的总和,然后除以该样本中所有特征出现次数的总和。

    3. 如果

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

    中的某一项为0,则其联合概率的乘积也可能为0,即2中公式的分子为0,为了避免这种现象出现,一般情况下会将这一项初始化为1,当然为了保证概率相等,分母应对应初始化为2(这里因为是2类,所以加2,如果是k类就需要加k,术语上叫做laplace光滑, 分母加k的原因是使之满足全概率公式)。

    朴素贝叶斯的优点:对小规模的数据表现很好,适合多分类任务,适合增量式训练。

    缺点:对输入数据的表达形式很敏感。

     

    决策树:决策树中很重要的一点就是选择一个属性进行分枝,因此要注意一下信息增益的计算公式,并深入理解它。

    信息熵的计算公式如下:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    其中的n代表有n个分类类别(比如假设是2类问题,那么n=2)。分别计算这2类样本在总样本中出现的概率p1和p2,这样就可以计算出未选中属性分枝前的信息熵。

    现在选中一个属性xi用来进行分枝,此时分枝规则是:如果xi=vx的话,将样本分到树的一个分支;如果不相等则进入另一个分支。很显然,分支中的样本很有可能包括2个类别,分别计算这2个分支的熵H1和H2,计算出分枝后的总信息熵H’=p1*H1+p2*H2.,则此时的信息增益ΔH=H-H’。以信息增益为原则,把所有的属性都测试一边,选择一个使增益最大的属性作为本次分枝属性。

    决策树的优点:计算量简单,可解释性强,比较适合处理有缺失属性值的样本,能够处理不相关的特征;

    缺点:容易过拟合(后续出现了随机森林,减小了过拟合现象)。

     

    Logistic回归:Logistic是用来分类的,是一种线性分类器,需要注意的地方有:

    1. logistic函数表达式为:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    其导数形式为:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    2. logsitc回归方法主要是用最大似然估计来学习的,所以单个样本的后验概率为:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    到整个样本的后验概率:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    其中:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    通过对数进一步化简为:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

     

    3. 其实它的loss function为-l(θ),因此我们需使loss function最小,可采用梯度下降法得到。梯度下降法公式为:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    Logistic回归优点:

    1. 实现简单

    2. 分类时计算量非常小,速度很快,存储资源低;

    缺点:

    1. 容易欠拟合,一般准确度不太高

    2. 只能处理两分类问题(在此基础上衍生出来的softmax可以用于多分类),且必须线性可分;

     

    线性回归:

    线性回归才是真正用于回归的,而不像logistic回归是用于分类,其基本思想是用梯度下降法对最小二乘法形式的误差函数进行优化,当然也可以用normal equation直接求得参数的解,结果为:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    而在LWLR(局部加权线性回归)中,参数的计算表达式为:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    因为此时优化的是:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    由此可见LWLR与LR不同,LWLR是一个非参数模型,因为每次进行回归计算都要遍历训练样本至少一次。

    线性回归优点:实现简单,计算简单;

    缺点:不能拟合非线性数据;

     

    KNN算法:KNN即最近邻算法,其主要过程为:

    1. 计算训练样本和测试样本中每个样本点的距离(常见的距离度量有欧式距离,马氏距离等);

    2. 对上面所有的距离值进行排序;

    3. 选前k个最小距离的样本;

    4. 根据这k个样本的标签进行投票,得到最后的分类类别;

    如何选择一个最佳的K值,这取决于数据。一般情况下,在分类时较大的K值能够减小噪声的影响。但会使类别之间的界限变得模糊。一个较好的K值可通过各种启发式技术来获取,比如,交叉验证。另外噪声和非相关性特征向量的存在会使K近邻算法的准确性减小。

    近邻算法具有较强的一致性结果。随着数据趋于无限,算法保证错误率不会超过贝叶斯算法错误率的两倍。对于一些好的K值,K近邻保证错误率不会超过贝叶斯理论误差率。

    注:马氏距离一定要先给出样本集的统计性质,比如均值向量,协方差矩阵等。关于马氏距离的介绍如下:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

     

    KNN算法的优点:

    1. 思想简单,理论成熟,既可以用来做分类也可以用来做回归;

    2. 可用于非线性分类;

    3. 训练时间复杂度为O(n);

    4. 准确度高,对数据没有假设,对outlier不敏感;

    缺点:

    1. 计算量大;

    2. 样本不平衡问题(即有些类别的样本数量很多,而其它样本的数量很少);

    3. 需要大量的内存;

     

    SVM:

    要学会如何使用libsvm以及一些参数的调节经验,另外需要理清楚svm算法的一些思路:

    1. svm中的最优分类面是对所有样本的几何裕量最大(为什么要选择最大间隔分类器,请从数学角度上说明?网易深度学习岗位面试过程中有被问到。答案就是几何间隔与样本的误分次数间存在关系:

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

    ,其中的分母就是样本到分类间隔距离,分子中的R是所有样本中的最长向量值),即:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

     

    经过一系列推导可得为优化下面原始目标:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    2. 下面来看看拉格朗日理论:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    可以将1中的优化目标转换为拉格朗日的形式(通过各种对偶优化,KKD条件),最后目标函数为:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    我们只需要最小化上述目标函数,其中的α为原始优化问题中的不等式约束拉格朗日系数。

    3. 对2中最后的式子分别w和b求导可得:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    由上面第1式子可以知道,如果我们优化出了α,则直接可以求出w了,即模型的参数搞定。而上面第2个式子可以作为后续优化的一个约束条件。

    4. 对2中最后一个目标函数用对偶优化理论可以转换为优化下面的目标函数:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    而这个函数可以用常用的优化方法求得α,进而求得w和b。

    5. 按照道理,svm简单理论应该到此结束。不过还是要补充一点,即在预测时有:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    那个尖括号我们可以用核函数代替,这也是svm经常和核函数扯在一起的原因。

    6. 最后是关于松弛变量的引入,因此原始的目标优化公式为:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    此时对应的对偶优化公式为:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    与前面的相比只是α多了个上界。

    SVM算法优点:

    1. 可用于线性/非线性分类,也可以用于回归;

    2. 低泛化误差;

    3. 容易解释;

    4. 计算复杂度较低;

    缺点:

    1. 对参数和核函数的选择比较敏感;

    2. 原始的SVM只比较擅长处理二分类问题;

     

    Boosting:

    主要以Adaboost为例,首先来看看Adaboost的流程图,如下:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    从图中可以看到,在训练过程中我们需要训练出多个弱分类器(图中为3个),每个弱分类器是由不同权重的样本(图中为5个训练样本)训练得到(其中第一个弱分类器对应输入样本的权值是一样的),而每个弱分类器对最终分类结果的作用也不同,是通过加权平均输出的,权值见上图中三角形里面的数值。那么这些弱分类器和其对应的权值是怎样训练出来的呢?

    下面通过一个例子来简单说明,假设的是5个训练样本,每个训练样本的维度为2,在训练第一个分类器时5个样本的权重各为0.2. 注意这里样本的权值和最终训练的弱分类器组对应的权值α是不同的,样本的权重只在训练过程中用到,而α在训练过程和测试过程都有用到。

    现在假设弱分类器是带一个节点的简单决策树,该决策树会选择2个属性(假设只有2个属性)的一个,然后计算出这个属性中的最佳值用来分类。

    Adaboost的简单版本训练过程如下:

    1. 训练第一个分类器,样本的权值D为相同的均值。通过一个弱分类器,得到这5个样本(请对应书中的例子来看,依旧是machine learning in action)的分类预测标签。与给出的样本真实标签对比,就可能出现误差(即错误)。如果某个样本预测错误,则它对应的错误值为该样本的权重,如果分类正确,则错误值为0. 最后累加5个样本的错误率之和,记为ε。

    2. 通过ε来计算该弱分类器的权重α,公式如下:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    3. 通过α来计算训练下一个弱分类器样本的权重D,如果对应样本分类正确,则减小该样本的权重,公式为:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    如果样本分类错误,则增加该样本的权重,公式为:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    4. 循环步骤1,2,3来继续训练多个分类器,只是其D值不同而已。

    测试过程如下:

    输入一个样本到训练好的每个弱分类中,则每个弱分类都对应一个输出标签,然后该标签乘以对应的α,最后求和得到值的符号即为预测标签值。

    Boosting算法的优点:

    1. 低泛化误差;

    2. 容易实现,分类准确率较高,没有太多参数可以调;

    3. 缺点:

    4. 对outlier比较敏感;

     

    聚类:

    根据聚类思想划分:

    1. 基于划分的聚类:

    K-means, k-medoids(每一个类别中找一个样本点来代表),CLARANS.

    k-means是使下面的表达式值最小:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    k-means算法的优点:

    (1)k-means算法是解决聚类问题的一种经典算法,算法简单、快速。

    (2)对处理大数据集,该算法是相对可伸缩的和高效率的,因为它的复杂度大约是O(nkt),其中n是所有对象的数目,k是簇的数目,t是迭代的次数。通常k<<n。这个算法通常局部收敛。

    (3)算法尝试找出使平方误差函数值最小的k个划分。当簇是密集的、球状或团状的,且簇与簇之间区别明显时,聚类效果较好。

    缺点:

    (1)k-平均方法只有在簇的平均值被定义的情况下才能使用,且对有些分类属性的数据不适合。

    (2)要求用户必须事先给出要生成的簇的数目k。

    (3)对初值敏感,对于不同的初始值,可能会导致不同的聚类结果。

    (4)不适合于发现非凸面形状的簇,或者大小差别很大的簇。

    (5)对于"噪声"和孤立点数据敏感,少量的该类数据能够对平均值产生极大影响。

    2. 基于层次的聚类:

    自底向上的凝聚方法,比如AGNES。

    自上向下的分裂方法,比如DIANA。

    3. 基于密度的聚类:DBSACN,OPTICS,BIRCH(CF-Tree),CURE.

    4. 基于网格的方法:STING, WaveCluster.

    5. 基于模型的聚类:EM,SOM,COBWEB.

    推荐系统:推荐系统的实现主要分为两个方面:基于内容的实现和协同滤波的实现。

    基于内容的实现:不同人对不同电影的评分这个例子,可以看做是一个普通的回归问题,因此每部电影都需要提前提取出一个特征向量(即x值),然后针对每个用户建模,即每个用户打的分值作为y值,利用这些已有的分值y和电影特征值x就可以训练回归模型了(最常见的就是线性回归)。

    这样就可以预测那些用户没有评分的电影的分数。(值得注意的是需对每个用户都建立他自己的回归模型)

    从另一个角度来看,也可以是先给定每个用户对某种电影的喜好程度(即权值),然后学出每部电影的特征,最后采用回归来预测那些没有被评分的电影。

     

    当然还可以是同时优化得到每个用户对不同类型电影的热爱程度以及每部电影的特征。

    基于协同滤波的实现:协同滤波(CF)可以看做是一个分类问题,也可以看做是矩阵分解问题。协同滤波主要是基于每个人自己的喜好都类似这一特征,它不依赖于个人的基本信息。

    比如刚刚那个电影评分的例子中,预测那些没有被评分的电影的分数只依赖于已经打分的那些分数,并不需要去学习那些电影的特征。

    SVD将矩阵分解为三个矩阵的乘积,公式如下所示:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    中间的矩阵sigma为对角矩阵,对角元素的值为Data矩阵的奇异值(注意奇异值和特征值是不同的),且已经从大到小排列好了。即使去掉特征值小的那些特征,依然可以很好的重构出原始矩阵。如下图所示:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    其中更深的颜色代表去掉小特征值重构时的三个矩阵。

    果m代表商品的个数,n代表用户的个数,则U矩阵的每一行代表商品的属性,现在通过降维U矩阵(取深色部分)后,每一个商品的属性可以用更低的维度表示(假设为k维)。这样当新来一个用户的商品推荐向量X,则可以根据公式X'*U1*inv(S1)得到一个k维的向量,然后在V’中寻找最相似的那一个用户(相似度测量可用余弦公式等),根据这个用户的评分来推荐(主要是推荐新用户未打分的那些商品)。

     

    pLSA:由LSA发展过来,而早期LSA的实现主要是通过SVD分解。pLSA的模型图如下

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    公式中的意义如下:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

     

    LDA主题模型,概率图如下:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    和pLSA不同的是LDA中假设了很多先验分布,且一般参数的先验分布都假设为Dirichlet分布,其原因是共轭分布时先验概率和后验概率的形式相同。

     

    GDBT:GBDT(Gradient Boosting Decision Tree) 又叫 MART(Multiple Additive Regression Tree),好像在阿里内部用得比较多(所以阿里算法岗位面试时可能会问到),它是一种迭代的决策树算法,该算法由多棵决策树组成,所有树的输出结果累加起来就是最终答案。

    它在被提出之初就和SVM一起被认为是泛化能力(generalization)较强的算法。近些年更因为被用于搜索排序的机器学习模型而引起大家关注。

    GBDT是回归树,不是分类树。其核心就在于,每一棵树是从之前所有树的残差中来学习的。为了防止过拟合,和Adaboosting一样,也加入了boosting这一项。

     

    Regularization作用是

    1. 数值上更容易求解;

    2. 特征数目太大时更稳定;

    3. 控制模型的复杂度,光滑性。复杂性越小且越光滑的目标函数泛化能力越强。而加入规则项能使目标函数复杂度减小,且更光滑。

    4. 减小参数空间;参数空间越小,复杂度越低。

    5. 系数越小,模型越简单,而模型越简单则泛化能力越强(Ng宏观上给出的解释)。

    6. 可以看成是权值的高斯先验。

     

    异常检测:可以估计样本的密度函数,对于新样本直接计算其密度,如果密度值小于某一阈值,则表示该样本异常。而密度函数一般采用多维的高斯分布。

    如果样本有n维,则每一维的特征都可以看作是符合高斯分布的,即使这些特征可视化出来不太符合高斯分布,也可以对该特征进行数学转换让其看起来像高斯分布,比如说x=log(x+c), x=x^(1/c)等。异常检测的算法流程如下:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    其中的ε也是通过交叉验证得到的,也就是说在进行异常检测时,前面的p(x)的学习是用的无监督,后面的参数ε学习是用的有监督。那么为什么不全部使用普通有监督的方法来学习呢(即把它看做是一个普通的二分类问题)?

    主要是因为在异常检测中,异常的样本数量非常少而正常样本数量非常多,因此不足以学习到好的异常行为模型的参数,因为后面新来的异常样本可能完全是与训练样本中的模式不同。

     

    EM算法:有时候因为样本的产生和隐含变量有关(隐含变量是不能观察的),而求模型的参数时一般采用最大似然估计,由于含有了隐含变量,所以对似然函数参数求导是求不出来的,这时可以采用EM算法来求模型的参数的(对应模型参数个数可能有多个),

    EM算法一般分为2步:

    E步:选取一组参数,求出在该参数下隐含变量的条件概率值;

    M步:结合E步求出的隐含变量条件概率,求出似然函数下界函数(本质上是某个期望函数)的最大值。

    重复上面2步直至收敛,公式如下所示:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

     

    M步公式中下界函数的推导过程:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    EM算法一个常见的例子就是GMM模型,每个样本都有可能由k个高斯产生,只不过由每个高斯产生的概率不同而已,因此每个样本都有对应的高斯分布(k个中的某一个),此时的隐含变量就是每个样本对应的某个高斯分布。

    GMM的E步公式如下(计算每个样本对应每个高斯的概率):

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

     

    更具体的计算公式为:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

     

    M步公式如下(计算每个高斯的比重,均值,方差这3个参数):

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

     

    Apriori是关联分析中比较早的一种方法,主要用来挖掘那些频繁项集合。其思想是:

    1. 如果一个项目集合不是频繁集合,那么任何包含它的项目集合也一定不是频繁集合;

    2. 如果一个项目集合是频繁集合,那么它的任何非空子集也是频繁集合;

    Aprioir需要扫描项目表多遍,从一个项目开始扫描,舍去掉那些不是频繁的项目,得到的集合称为L,然后对L中的每个元素进行自组合,生成比上次扫描多一个项目的集合,该集合称为C,接着又扫描去掉那些非频繁的项目,重复…

    看下面这个例子,元素项目表格:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

     

    如果每个步骤不去掉非频繁项目集,则其扫描过程的树形结构如下:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    在其中某个过程中,可能出现非频繁的项目集,将其去掉(用阴影表示)为:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

     

    FP Growth是一种比Apriori更高效的频繁项挖掘方法,它只需要扫描项目表2次。其中第1次扫描获得当个项目的频率,去掉不符合支持度要求的项,并对剩下的项排序。第2遍扫描是建立一颗FP-Tree(frequent-patten tree)。

    接下来的工作就是在FP-Tree上进行挖掘,比如说有下表:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    它所对应的FP_Tree如下:

     

    「收藏」人工智能中常见机器学习算法优缺点有哪些?

     

     

    然后从频率最小的单项P开始,找出P的条件模式基,用构造FP_Tree同样的方法来构造P的条件模式基的FP_Tree,在这棵树上找出包含P的频繁项集。

    依次从m,b,a,c,f的条件模式基上挖掘频繁项集,有些项需要递归的去挖掘,比较麻烦,比如m节点。

    展开全文
  • 车辆轨迹预测方法优缺点总结: 马尔科夫模型: 优点: 1、能够计算出具有维修能力和多重降级状态的系统的概率。 缺点: 预测准确率比较低。 一阶马尔科夫模型只考虑当前轨迹点对未来轨迹点的影响,不能充分...

    车辆轨迹预测方法的优缺点总结:

    马尔科夫模型:

    优点

    1、能够计算出具有维修能力和多重降级状态的系统的概率。

    缺点:

    1. 预测准确率比较低。
    2. 一阶马尔科夫模型只考虑当前轨迹点对未来轨迹点的影响,不能充分地利用历史轨迹点数据。
    3. 高阶马尔科夫预测模型增加了模型计算复杂度,不适用于海量轨迹数据的训练学习。
    4. 对车辆轨迹的波动比较敏感。
    5. 不适宜用于系统中长期预测。
    6. 马尔科夫模型是一种概率转移模型,它涉及的概率转移矩阵是能否进行准确预测的关键。一般的,如果某变量可以使用Markov模型来预测,它的前提条件是,在各个期间或者状态时,变量面临的下一个期间或者状态的转移概率都是一样的、不随时间变化的。一旦转移概率有所变化,Markov模型必须改变转移概率矩阵的参数,否则,预测的结果将会有很大的偏差。

     

    高斯混合模型:

    优点:

    1. 是一种非参数的概率模型,对具有噪声点的轨迹数据预测效果较好。
    2. 可避免了轨迹数据离散性质的弊端。
    3. 可以根据概率模型的精确度评判模型的预测误差。
    4. 高斯过程可以很好地表达车辆运动轨迹分布的统计特征。
    5. 使用的训练数据集规模比较小。
    6. 可以根据不同历史数据自适应训练获取。

    缺点:

    1. 单独使用该模型时,解决不了不同时间点预测误差差别较大的问题。
    2. 不是稀疏的。也就是说它们使用完整的样本/特性信息来进行预测。
    3. 在高维空间失去了有效性。当特征的个数超过几十后。
    4. 模型本身是非参数性(无需人为设置参数)求解,导致其计算量随着数据增加变大,在模型训练中,参数都是通过最优化边缘似然获取的。
    5. 该模型构造过程过于复杂,花费时间代价相对较高。

     

    贝叶斯模型:

    优点:

    1. 对小规模的数据表现很好,能处理多分类任务,适合增量式训练,尤其是数据量超出内存时,可以一批批的去增量训练。
    2. 对缺失数据不太敏感。

    缺点:

    1. 时间消耗比较大。
    2. 对输入数据的表达形式比较敏感。
    3. 需要知道先验概率,且先验概率很多时候取决于假设,假设的模型可以有很多种,因此,在某些时候会由于假设的先验模型的原因导致预测效果不佳。
    4. 分类决策存在一定的错误率。

    卡尔曼滤波:

    优点:

    1. 处理的轨迹数据无噪声点时预测效果比较有效。
    2. 对短时间内(1步或2步)的预测比较稳定准确的判断。

    缺点:

    1. 长时间(如10秒以上或者5步以上)的轨迹预测由于预测误差的变大严重影响预测准确性,并且模型复杂性增加。
    2. 仅仅对轨迹进行线性回归预测,没有对不同的轨迹模式进行聚类分析,因此,预测误差最大。
    3. 对噪声数据的变化比较敏感,随着噪声增大,预测误差不断增大,近似成线性。
    4. 时间代价比较高。

     

    LSTM模型:

    优点:

    1. 弥补了RNN的缺陷,RNN在处理long term memory的时候存在缺陷,它只考虑最近的状态,LSTM的细胞状态会决定哪些状态应该被留下来,哪些状态应该被遗忘。
    2.  LSTM可以消除一些RNN的梯度消失问题。

    缺点:

    1、不能对抗梯度爆炸问题。

    2、梯度问题在LSTM里得到了一定程度的解决,但还是不够。

    3、LSTM是可以记住大量更长长期的信息,但是只能记住100个量级,而不是1000个量级,或者更长的序列。

    4、计算费时。每一个LSTM的cell里面都意味着有4个全连接层(MLP),如果LSTM的时间跨度很大,并且网络又很深,这个计算量会很大,很耗时。

     

    总结:

    经过对轨迹预测的各种方法进行整理和总结,觉得还是LSTM更加适合进行车辆的轨迹预测。理由如下:

    1. 通过在各个网站进行文献的查找,事实证明,在对车辆的轨迹预测方面,基于LSTM方法可以进行查阅的文献是最多的。
    2. 通过自己看的一部分论文,发现有好几篇论文(关于轨迹预测)实验的数据集是相同的。这为下一步论文实验的数据对比提供了参考。(注:本文是结合自身的需要进行的总结,希望批评指正和补充!)

     

    展开全文
  • KNN算法优缺点、原理及参数最优解

    千次阅读 2019-11-28 11:44:29
    优缺点: 优点:精度高、对异常值不敏感、无数据输入假定。 缺点:时间复杂度高、空间复杂度高。 当样本不平衡时,比如一个类的样本容量很大,其他类的样本容量很小,输入一个样本的时候,K个临近值中大多数都...

    1. KNN算法简介

    • 1.1 简述

    • 简单地说,K-近邻算法采用测量不同特征值之间的距离方法进行分类(k-Nearest Neighbor,KNN)

    • 1.2 优缺点

      • 优点:精度高、对异常值不敏感、无数据输入假定。

      • 缺点:时间复杂度高、空间复杂度高。

      1. 当样本不平衡时,比如一个类的样本容量很大,其他类的样本容量很小,输入一个样本的时候,K个临近值中大多数都是大样本容量的那个类,这时可能就会导致分类错误。改进方法是对K临近点进行加权,也就是距离近的点的权值大,距离远的点权值小。

      2. 计算量较大,每个待分类的样本都要计算它到全部点的距离,根据距离排序才能求得K个临近点,改进方法是:先对已知样本点进行剪辑,事先去除对分类作用不大的样本。

    • 1.3 适用数据范围

      • 标称型:标称型目标变量的结果只在有限目标集中取值,如真与假(标称型目标变量主要用于分类)

      • 数值型:数值型目标变量则可以从无限的数值集合中取值,如0.100,42.001等 (数值型目标变量主要用于回归分析)

    2. 工作原理

    2.1 训练样本集

    • 存在一个样本数据集合,也称作训练样本集,并且样本集中每个数据都存在标签,即我们知道样本集中每一数据 与所属分类的对应关系。

    • 输人没有标签的新数据后,将新数据的每个特征与样本集中数据对应的 特征进行比较,然后算法提取样本集中特征最相似数据(最近邻)的分类标签。

    • 一般来说,我们 只选择样本数据集中前K个最相似的数据,这就是K-近邻算法中K的出处,通常K是不大于20的整数。 最后 ,选择K个最相似数据中出现次数最多的分类,作为新数据的分类。

    2.2 电影类别的KNN分析

    • 如何进行电影分类

      • 众所周知,电影可以按照题材分类,然而题材本身是如何定义的?由谁来判定某部电影属于哪 个题材?也就是说同一题材的电影具有哪些公共特征?这些都是在进行电影分类时必须要考虑的问 题。没有哪个电影人会说自己制作的电影和以前的某部电影类似,但我们确实知道每部电影在风格 上的确有可能会和同题材的电影相近。那么动作片具有哪些共有特征,使得动作片之间非常类似, 而与爱情片存在着明显的差别呢?动作片中也会存在接吻镜头,爱情片中也会存在打斗场景,我们 不能单纯依靠是否存在打斗或者亲吻来判断影片的类型。但是爱情片中的亲吻镜头更多,动作片中 的打斗场景也更频繁,基于此类场景在某部电影中出现的次数可以用来进行电影分类。

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    2.3 欧几里得距离(Euclidean Distance)

    • 欧式距离是最常见的距离度量,衡量的是多维空间中各个点之间的绝对距离,公式如下:

    d i s t ( X , Y ) = ∑ i = 0 n ( X i − Y i ) 2 = ( X 1 − Y 1 ) 2 + ( X 2 − Y 2 ) 2 + ( X 3 − Y 3 ) 2 + … … + ( X i − Y i ) dist(X,Y) = \sqrt{\sum_{i=0}^{n}(X_i - Y_i)^2} = \sqrt{(X_1-Y_1)^2 + (X_2-Y_2)^2+(X_3-Y_3)^2+……+(X_i-Y_i)} dist(X,Y)=i=0n(XiYi)2 =(X1Y1)2+(X2Y2)2+(X3Y3)2++XiYi

    2.4 计算过程图

    • 在这里插入图片描述

    2.5 kNN近邻分类算法的原理

    在这里插入图片描述

    • 从上图中我们可以看到,图中的数据集都有了自己的标签,一类是蓝色的正方形,一类是红色的三角形,那个绿色的圆形是我们待分类的数据

    • 如果K=3,那么离绿色点最近的有2个红色三角形和1个蓝色的正方形,这3个点投票,于是绿色的这个待分类点属于红色的三角形.

    • 如果K=5,那么离绿色点最近的有2个红色三角形和3个蓝色的正方形,这5个点投票,于是绿色的这个待分类点属于蓝色的正方形

    • 我们可以看到,KNN本质是基于一种数据统计的方法!其实很多机器学习算法也是基于数据统计的

    • 总结:KNN是一种基于记忆的学习(memory-based learning),也是基于实例的学习(instance-based learning),属于惰性学习(lazy learning)。即它没有明显的前期训练过程,而是程序开始运行时,把数据集加载到内存后,不需要进行训练,就可以开始分类了。

    3. K值最优解

    • 3.1 原因:

      • k值过大,非相似数据被包含较多,造成噪声增加而导致分类结果的降低。

      • k值过小,得到的邻近数过少,会降低分类精度,同时也会放大噪声数据的干扰。

    • 3.2 方法:

      • k一般低于训练样本数的平方根,通常采用交叉检验来确定。
    • 3.3 KNN算法参数的筛选代码

      ### 导包,加载数据
    
    import numpy as np
    
    from sklearn.neighbors import KNeighborsClassifier
    
    from sklearn import datasets
    
    # model_selection:模型选择
    # cross_val_score  cross:交叉,validation:验证(测试)
    # 交叉验证
    from sklearn.model_selection import cross_val_score
    
    # 通过训练样本数的开平方对k值进行参考
    X,y = datasets.load_iris(True)
    X.shape[0]**0.5
    

    结果是:12.24744871391589,所以k值的取值范围是1到13

    应用cross_val_score筛选最合适的邻居数量

    erros = []
    for k in range(1,14):
        knn = KNeighborsClassifier(n_neighbors=k)
        score = cross_val_score(knn,X,y,scoring='accuracy',cv = 6).mean()
    #     误差越小,说明k选择越合适,越好
        erros.append(1 - score)
        
    import matplotlib.pyplot as plt
    %matplotlib inline
    # k = 11时,误差最小,说明k = 11对鸢尾花来说,最合适的k值
    plt.plot(np.arange(1,14),erros)
    

    在这里插入图片描述

    通过上面代码所得图,可以看出当k = 11时,误差最小,k值最好

    多参数组合使用cross_val_score筛选最合适的参数组合

    result = {}
    weights = ['distance','uniform']
    for k in range(1,14):
        for w in weights:
            knn = KNeighborsClassifier(n_neighbors=k,weights=w)
            sm = cross_val_score(knn,X,y,scoring='accuracy',cv = 6).mean()
            result[w + str(k)] = sm
    result
    
    {'uniform1': 0.9591049382716049,
     'distance1': 0.9591049382716049,
     'uniform2': 0.9390432098765431,
     'distance2': 0.9591049382716049,
     'uniform3': 0.9660493827160493,
     'distance3': 0.9660493827160493,
     'uniform4': 0.9660493827160493,
     'distance4': 0.9660493827160493,
     'uniform5': 0.9660493827160493,
     'distance5': 0.9660493827160493,
     'uniform6': 0.9729938271604938,
     'distance6': 0.9729938271604938,
     'uniform7': 0.9729938271604938,
     'distance7': 0.9729938271604938,
     'uniform8': 0.9591049382716049,
     'distance8': 0.9729938271604938,
     'uniform9': 0.9660493827160493,
     'distance9': 0.9729938271604938,
     'uniform10': 0.9729938271604938,
     'distance10': 0.9729938271604938,
     'uniform11': 0.98070987654321,
     'distance11': 0.9799382716049383,
     'uniform12': 0.9737654320987654,
     'distance12': 0.9799382716049383,
     'uniform13': 0.9737654320987654,
     'distance13': 0.9729938271604938}
    

    通过输出结果可以看出,当weights=uniform,且k=11时,误差最小,是k和weights的最优解

    如果需要得到其他参数的最优解,方法同上

    展开全文
  • 使用非参数检验的优缺点 在上面的讨论中,你可能已经注意到,我提到了使用非参数测试可能有利或不利的几点,因此现在让我们共同来看一下这些点。 优点 使用非参数检验而不是参数检验的优点是 1.即使样本量很小,非...
  • 本文提出了一种用于确定统计学习机(SLM)参数结构的识别函数(IF)方法。 这涉及研究三个相关... 我们将IF方法与现有标准进行比较,并从理论和应用角度讨论其优缺点。 提出了一些文献中的模型实例来研究其参数结构。
  • 常见分类算法优缺点

    千次阅读 2018-10-21 21:36:54
    本文主要回顾下几个常用算法的适应场景及其优缺点! 机器学习算法太多了,分类、回归、聚类、推荐、图像识别领域等等,要想找到一个合适算法真的不容易,所以在实际应用中,我们一般都是采用启发式学习方式来实验。...
  • 深度学习中的卷积、dropout等方法使得其可以有效的学习高维数据,但是前提是需要很大量的数据,估算更大量极的参数,需要强大的计算能力。 优点:是目前特定领域的最先进技术,如:计算机视觉与语音识别。其在...
  • 模型优缺点总结

    千次阅读 2020-12-26 16:06:49
    优点: 不需要指定簇个数 可以发现任意形状的簇 擅长找到离群点(检测任务) 两个参数就够了 缺点: 高维数据有些困难(可以做降维) 参数难以选择(参数对结果的影响非常大) Sklearn中效率很慢(数据削减策略) ...
  • 参数统计

    千次阅读 2017-08-23 21:56:39
    参数统计 ... 非参数统计(Nonparametric statistics) ...什么是非参数统计2 ...非参数统计的适用范围3 ...非参数统计优缺点 [编辑] 什么是非参数统计  非参数统计是统计学的一个重要分支
  • 各种算法的优缺点

    千次阅读 2019-09-21 02:55:02
    遮挡情况下的误差并不满足高斯或者...https://www.52ml.net/15063.html,整理了朴树贝叶斯,逻辑回归,决策树,SVM等分类器的优缺点 1.SRC 1)、SRC对测试集中的噪声比较鲁棒,但是当训练集中同样含有噪声时,...
  • 最近开始接触Linux运维,安装了Nagios,zabbix和ganglia三种监控工具并使用了一周后总结出一些优缺点,这里贴出来以供参考 Nagios是一款开源的企业级监控系统,能够实现对系统CPU、磁盘、网络等方面参数的基本系统...
  •  霍夫变换(Hough Transform)换于1962年由Paul Hough 首次提出,后于1972年由Richard Duda和Peter Hart推广使用,是图像处理中从图像中检测几何形状的基本方法之一。经典霍夫变换用来检测图像中的直线,后来霍夫...
  • 为什么要做数据分析? 可以有效避免自己想当然的做事情,用客观数据分析出来的结果来堵住主观臆想的黑洞 可以为决策提供有说服力的支撑 ...常用的第三方统计平台优缺点分析 1.友盟+ 2010年4月在北...
  • 数据转化为正态分布的方法优缺点 文章目录数据转化为正态分布的方法优缺点对数变换平方根变换倒数变换平方根反正弦变换BOX-COX变换SPSS操作 对数变换 ​ 将原始数据X的对数值作为新的分布数据:X’=LGX。当原始...
  • 不依赖Hadoop复杂生态(像ES一样,开箱即用) 一些不足 不支持事务(这其实也是大部分OLAP数据库的缺点) 不擅长根据主键按行粒度查询(但是支持这种操作) 不擅长按行删除数据(但是支持这种操作) ClickHouse基础架构 1....
  • 前端埋点方法解析及优缺点分析

    千次阅读 2019-05-30 06:31:40
    1.文档说明本文档是对前端埋点方案的梳理,整个文档会对现在主流方向的前端埋点方案进行分析整理。意在帮助产品经理和开发人员了解用户现实使用需求,为...2.1代码埋点优缺点分析代码埋点就是开发人员在指定的位置通...
  • 手肘法是一个经验方法缺点是不能够自动化,因此研究员又提出来更先进的方法,其中包括比较有名的Gap Statistics方法,Gap Statistics方法的优点是不需要肉眼判断,只需要找到最大的Gap Statistics所对应的K即可,...
  • 机器学习常见算法优缺点汇总

    千次阅读 2018-05-20 18:50:03
    回归算法是统计机器学习的利器。在机器学习领域,人们说起回归,有时候是指一类问题,有时候是指一类算法,这一点常常会使初学者有所困惑。常见的回归算法包括:最小二乘法(Ordinary Least Square),逻辑回归...
  • 深入理解XGBoost,优缺点分析,原理推导及工程实现

    千次阅读 多人点赞 2019-12-26 20:04:00
    本文将从XGBoost的数学原理和工程实现上进行介绍,然后介绍XGBoost的优缺点,并在最后给出面试中经常遇到的关于XGBoost的问题。 2. XGBoost的原理推导 2.1 从目标函数开始,生成一棵树 XGBoost和GBDT两者都是...
  • SVM的优缺点

    万次阅读 2014-04-17 10:16:53
    支持向量机的优缺点? 答:优点:SVM理论提供了一种避开高维空间的复杂性,直接用此空间的内积函数(既是核函数),再利用在线性可分的情况下的求解方法直接求解对应的高维空间的决策问题.当核函数已知,可以简化高维空间...
  • ) 优点:一种记录和说明关系与复杂结构的易于理解的方法 缺点:行与方框的方法在显示复杂性方面受到限制;更难显示不那么正式的关系,比如人们如何在公司的层级制度之外合作 10 直方图 基于范围内每个值的出现频率...
  • (注:聚类方法是属于无监督的分类方式。) 2.聚类的分类 聚类方法主要划分为五大类: (1)基于层次的聚类 原理:试图在不同层次上对数据集进行划分,从而形成树形的聚类结构。数据集的划分可采用“自底向上”的...
  • SQL存储过程的优缺点

    千次阅读 2018-07-28 17:17:22
    存储过程是由一些SQL语句和控制语句组成的被封装起来的过程,它驻留在数据库中,可以被客户应用程序调用,用户通过指定存储过程的名字并给定参数(如果该存储过程带有参数)来调用执行它,也可以从另一个过程或...
  • 机器学习各种距离优缺点

    千次阅读 2019-12-27 21:55:07
    **缺点:**就大部分统计问题而言,欧氏距离是不能令人满意的。(每个坐标对欧氏距离的贡献是同等的。当坐标表示测量值时,它们往往带有大小不等的随机波动,在这种情况下,合理的方法是对坐标加权,...
  • 机器学习算法优缺点总结

    万次阅读 2018-06-30 15:16:40
      KNN将测试集的数据特征与训练集的数据进行特征比较,然后算法提取样本集中特征最近邻数据的分类标签,即KNN算法采用测量不同特征值之间的距离的方法进行分类。KNN的思路很简单,就是计算测试数据与类别中心的距离...
  • 各种算法对比以及各自的优缺点

    千次阅读 2019-03-07 16:58:29
    缺点: 1)假设属性之间相互独立,这往往并不成立。(喜欢吃番茄、鸡蛋,却不喜欢吃番茄炒蛋)。 2)需要知道先验概率。 3)分类决策存在错误率。 决策树 优点: 1)不需要任何领域知识或参数假设。 2)适合...
  • 各种分类算法优缺点比较

    万次阅读 2016-05-25 19:54:20
    一、决策树(Decision Trees)的优缺点 决策树的优点: 1、决策树易于理解和解释.人们在通过解释后都有能力去理解决策树所表达的意义。 2、对于决策树,数据的准备往往是简单或者是不必要的.其他的技术往往要求先把...
  • 深度学习 发展 优缺点

    千次阅读 2018-07-26 22:46:11
    由于早期的计算资源的限制,以及数据量不足,导致前2个时期提出的神经网络,大多规模很小,而且在一定程度上还不如传统的统计机器学习方法,而且神经网络的结构相对简单,因此并没有体现出神经网络的潜在价值。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,857
精华内容 15,942
关键字:

参数统计方法优缺点