第4章 確率論に基づく分類法：ナイーブベイズ
ナイーブ ベイズの概要
贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。本章首先介绍贝叶斯分类算法的基础——贝叶斯定理。最后，我们通过实例来讨论贝叶斯分类的中最简单的一种: 朴素贝叶斯分类。
ベイズ理論と条件付き確率
ベイズ理論
これで 2 種類のデータから構成されるデータセットができました。データの分布は次の図のようになります。
ここで、p1(x,y) を使用してデータ点 (x,y) がカテゴリー 1 (図の点で表されるカテゴリー) に属する確率を表し、p2(x,y) を使用してその確率を表します。データ ポイント (x,y) はカテゴリ 2 (図の三角形で表されるカテゴリ) に属しており、新しいデータ ポイント (x, y) については、次のルールを使用してそのカテゴリを決定できます。
- p1(x,y) > p2(x,y) の場合、カテゴリは 1 です。
- p2(x,y) > p1(x,y) の場合、カテゴリは 2 です。
つまり、確率が高いカテゴリを選択することになります。これは、最も高い確率で決定を選択するというベイジアン決定理論の核となる考え方です。
条件付き確率
p(x,y|c1) 表記に慣れている場合は、このセクションをスキップしてください。
7 つの石が入った瓶があり、そのうち 3 つは白、4 つは黒です。瓶から石をランダムに取り出した場合、それが白い石である確率はどのくらいですか? 石を取る可能性は 7 つあり、そのうち 3 つは白なので、白石が取れる確率は 3/7 です。では、黒石が出る確率はどれくらいでしょうか？確かに4/7ですね。白石の出現確率をP(白)で表しており、白石の数を石の総数で割った値となります。
これら 7 つの石が下の図のように 2 つのバケツに置かれている場合、上記の確率はどのように計算されるべきでしょうか?
P(白)かP(黒)を計算するとき、石が入っているバケツの情報が事前にわかっていれば結果は変わります。これを条件付き確率と呼びます。バケツBから白石が取れる確率を計算したとします。この確率はP(白|バケツB)と記録できます。これを「バケツBから石が出るという条件で白石が取り出せる確率」と呼びます。 」。P(white|bucketA) の値が 2/4、P(white|bucketB) の値が 1/3 であることは簡単にわかります。
条件付き確率の計算式は次のとおりです。
P(白|バケットB) = P(白とバケットB) / P(バケットB)
まず、バケツ B の白石の数を 2 つのバケツの石の合計数で割って、P(白とバケツ B) = 1/7 を求めます。次に、バケツ B には 3 つの石があるため、合計は石の数は 7 なので、P(bucketB) は 3/7 に等しくなります。したがって、P(白|バケットB) = P(白とバケットB) / P(バケットB) = (1/7) / (3/7) = 1/3となります。
条件付き確率を計算するもう 1 つの効率的な方法は、ベイズの基準と呼ばれます。ベイズの基準は、条件と結果を条件付き確率で交換する方法を示します。つまり、P(x|c) が既知で、P(c|x) が必要な場合は、次の計算方法を使用できます。
条件付き確率を使用して分類する
上で、ベイジアン決定理論では 2 つの確率 p1(x, y) と p2(x, y) の計算が必要であると述べました。
- p1(x, y) > p2(x, y) の場合、カテゴリ 1 に属します。
- p2(x, y) > p1(X, y) の場合、カテゴリ 2 に属します。
ベイズ決定理論のすべてではありません。p1() と p2() は説明をできるだけ簡略化するために使用していますが、実際に計算して比較する必要があるのは p(c1|x, y) と p(c2|x, y) です。これらの記号の具体的な意味は次のとおりです。x、y で表されるデータ ポイントが与えられた場合、そのデータ ポイントがカテゴリ c1 に由来する確率はいくらですか? データ ポイントがカテゴリ c2 からのものである確率はどれくらいですか? これらの確率は確率 p(x, y|c1) と同じではありませんが、ベイズの基準を使用して確率の条件と結果を交換できることに注意してください。具体的には、ベイズの基準を適用すると次のようになります。
上記の定義を使用すると、ベイズ分類基準は次のように定義できます。
- P(c1|x, y) > P(c2|x, y) の場合、カテゴリ c1 に属します。
- P(c2|x, y) > P(c1|x, y) の場合、カテゴリ c2 に属します。
文書分類では、文書全体 (電子メールなど) がインスタンスですが、電子メール内の特定の要素が特徴を構成します。文書中に出現する単語を観察し、各単語を特徴量とし、各単語の出現の有無を特徴量の値とすることで、単語の数だけ特徴量が得られます。語彙。
機能は互いに独立していると仮定します。いわゆる独立性とは、統計的な意味での独立性を指します。つまり、特徴や単語が出現する可能性は、他の単語との近接性とは無関係です。たとえば、「私たち」における「私」と「私たち」の出現は、 「確率は、これら 2 つの単語の隣接とは何の関係もありません。この仮定は、まさにナイーブ ベイズ分類器におけるナイーブという言葉の意味です。Naive Bayes 分類器のもう 1 つの仮定は、すべての特徴が同等に重要であるということです。
注:単純ベイズ分類器は通常 2 つの方法で実装されます。1 つはベルヌーイ モデルに基づくもの、もう 1 つは多項式モデルに基づくものです。ここでは前者の実装方法を使用します。この実装では、単語が文書内に出現する回数は考慮されず、単語が存在しないことのみが考慮されるため、この意味で、単語の重みが等しいと仮定するのと同じです。
ナイーブベイズシナリオ
機械学習の重要な用途は、文書の自動分類です。
文書分類では、文書全体 (電子メールなど) がインスタンスですが、電子メール内の特定の要素が特徴を構成します。文書中に出現する単語を観察し、各単語を特徴量とし、各単語の出現の有無を特徴量の値とすることで、単語の数だけ特徴量が得られます。語彙。
Naive Bayes は、上で紹介したベイズ分類器の拡張であり、文書分類に一般的に使用されるアルゴリズムです。以下では、ナイーブ ベイズ分類に関するいくつかの実践的なプロジェクトを実行します。
単純ベイズの原理
ナイーブベイズの仕組み
提取所有文档中的词条并进行去重
获取文档的所有类别
计算每个类别中的文档数目
对每篇训练文档:
对每个类别:
如果词条出现在文档中-->增加该词条的计数值（for循环或者矩阵相加）
增加所有词条的计数值（此类别下词条总数）
对每个类别:
对每个词条:
将该词条的数目除以总词条数目得到的条件概率（P(词条|类别)）
返回该文档属于每个类别的条件概率（P(类别|文档的所有词条)）
ナイーブベイズの開発プロセス
收集数据: 可以使用任何方法。
准备数据: 需要数值型或者布尔型数据。
分析数据: 有大量特征时，绘制特征作用不大，此时使用直方图效果更好。
训练算法: 计算不同的独立特征的条件概率。
测试算法: 计算错误率。
使用算法: 一个常见的朴素贝叶斯应用是文档分类。可以在任意的分类场景中使用朴素贝叶斯分类器，不一定非要是文本。
Naive Bayesアルゴリズムの特徴
优点: 在数据较少的情况下仍然有效，可以处理多类别问题。
缺点: 对于输入数据的准备方式较为敏感。
适用数据类型: 标称型数据。
ナイーブベイズプロジェクトの事例
プロジェクト事例 1: コミュニティ掲示板での侮辱的なコメントのブロック
プロジェクト概要
オンライン コミュニティの掲示板での虐待的なコメントをブロックするクイック フィルターを構築します。コメントに否定的または侮辱的な言葉が使用されている場合、そのコメントは不適切としてマークされます。この問題に対して、侮辱的なカテゴリと非侮辱的なカテゴリという 2 つのカテゴリが確立され、それぞれ 1 と 0 で表されます。
開発プロセス
收集数据: 可以使用任何方法
准备数据: 从文本中构建词向量
分析数据: 检查词条确保解析的正确性
训练算法: 从词向量计算概率
测试算法: 根据现实情况修改分类器
使用算法: 对社区留言板言论进行分类
データの収集: 任意の方法を使用できます
この例は、私たちが自分たちで作成した語彙リストです。
def loadDataSet():
'''
创建数据集,都是假的 fake data set
:return: 单词列表postinglist, 所属类别classvec
'''
postingList=[['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']]
classVec=[0,1,0,1,0,1] # 1代表侮辱性文字，0 代表正常言论
return postingList,classVec
データの準備: テキストから単語ベクトルを構築する
def createVocabList(dataSet):
"""
获取所有单词的集合
:param dataSet:数据集
:return:所有单词的集合(即不含重复元素的单词列表)
"""
vocabSet=set([])
for document in dataSet:
# | 求两个集合的并集
vocabSet=vocabSet|set(document)
return list(vocabSet)
def setOfWords2Vec(vocabList,inputSet):
"""
遍历查看该单词是否出现，出现该单词则将该单词置1
:param vocabList:所有单词集合列表
:param inputSet:输入数据集
:return:匹配列表[0,1,0,1...]，其中 1与0 表示词汇表中的单词是否出现在输入的数据集中
"""
# 创建一个和词汇表等长的向量，并将其元素都设置为0
returnVec=[0]*len(vocabList)
# 遍历文档中的所有单词，如果出现了词汇表中的单词，则将输出的文档向量中的对应值设为1
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)]=1
else:
print("the word:%s is not in my Vocabulary!"%word)
return returnVec
データの分析: 用語をチェックして、解析が正しいことを確認します。
関数の実行を確認し、語彙リストを確認し、重複した単語がないことを確認し、必要に応じて並べ替えます。
>>> listOPosts, listClasses = bayes.loadDataSet()
>>> myVocabList = bayes.createVocabList(listOPosts)
>>> myVocabList
['cute', 'love', 'help', 'garbage', 'quit', 'I', 'problems', 'is', 'park',
'stop', 'flea', 'dalmation', 'licks', 'food', 'not', 'him', 'buying', 'posting', 'has', 'worthless', 'ate', 'to', 'maybe', 'please', 'dog', 'how',
'stupid', 'so', 'take', 'mr', 'steak', 'my']
関数の有効性を確認します。例: myVocabList のインデックス 2 の要素は何の単語ですか? それは助けになるはずです。この単語は最初の文書に出現するので、4 番目の文書に出現するかどうかを確認します。
>>> bayes.setOfWords2Vec(myVocabList, listOPosts[0])
[0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1]
>>> bayes.setOfWords2Vec(myVocabList, listOPosts[3])
[0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
トレーニング アルゴリズム: 単語ベクトルから確率を計算します。
これで、単語が文書内に出現するかどうか、またその文書がどのカテゴリに属するかがわかりました。次に、ベイジアン基準を書き換えて、前の x, y をwに置き換えます。太字のwは、これがベクトルであること、つまり複数の値で構成されていることを示します。この例では、値の数は語彙内の単語の数と同じです。
上記の式を使用してクラスごとにこの値を計算し、2 つの確率値を比較します。
質問: 上記のコード実装では P(w) が計算されないのはなぜですか?
回答: 上の式によれば、各 ci について P(w) が固定されているため、右側の式は左側の式と同等であることがわかります。そして、分類を決定するには左側の分子のサイズを比較するだけで済みます。その後、右側の分子のサイズを比較することで決定と分類を行うように単純化できます。
まず、確率 p(ci) は、カテゴリ i (侮辱的なコメントまたは非侮辱的なコメント) の文書数を文書の総数で割ることによって計算できます。次に、単純ベイズ仮説が使用されるp( w | ci) を計算します。w が独立した特徴に拡張される場合、上記の確率は p(w0, w1, w2...wn | ci) と書くことができます。ここでは、すべての単語が互いに独立していると仮定します。この仮定は、条件付き独立性仮定とも呼ばれます（たとえば、2 人の人 A と B がサイコロを振ったとき、確率は互いに影響しません。つまり、独立しています）。 A が 2 点を投げるとき、B は 3 点を投げます。確率は 1/6 * 1/6)、つまり、p(w0 | ci)p(w1 | ci)p(w2 | ci) を使用できることを意味します。 …p(wn | ci) を使用して上記の確率を計算します。地球では計算プロセスが非常に簡略化されます。
単純ベイズ分類器トレーニング関数
def _trainNB0(trainMatrix, trainCategory):
"""
训练数据原版
:param trainMatrix: 文件单词矩阵 [[1,0,1,1,1....],[],[]...]
:param trainCategory: 文件对应的类别[0,1,1,0....]，列表长度等于单词矩阵数，其中的1代表对应的文件是侮辱性文件，0代表不是侮辱性矩阵
:return:
"""
# 文件数
numTrainDocs = len(trainMatrix)
# 单词数
numWords = len(trainMatrix[0])
# 侮辱性文件的出现概率，即trainCategory中所有的1的个数，
# 代表的就是多少个侮辱性文件，与文件的总数相除就得到了侮辱性文件的出现概率
pAbusive = sum(trainCategory) / float(numTrainDocs)
# 构造单词出现次数列表
p0Num = zeros(numWords) # [0,0,0,.....]
p1Num = zeros(numWords) # [0,0,0,.....]
# 整个数据集单词出现总数
p0Denom = 0.0
p1Denom = 0.0
for i in range(numTrainDocs):
# 是否是侮辱性文件
if trainCategory[i] == 1:
# 如果是侮辱性文件，对侮辱性文件的向量进行加和
p1Num += trainMatrix[i] #[0,1,1,....] + [0,1,1,....]->[0,2,2,...]
# 对向量中的所有元素进行求和，也就是计算所有侮辱性文件中出现的单词总数
p1Denom += sum(trainMatrix[i])
else:
p0Num += trainMatrix[i]
p0Denom += sum(trainMatrix[i])
# 类别1，即侮辱性文档的[P(F1|C1),P(F2|C1),P(F3|C1),P(F4|C1),P(F5|C1)....]列表
# 即 在1类别下，每个单词出现的概率
p1Vect = p1Num / p1Denom# [1,2,3,5]/90->[1/90,...]
# 类别0，即正常文档的[P(F1|C0),P(F2|C0),P(F3|C0),P(F4|C0),P(F5|C0)....]列表
# 即 在0类别下，每个单词出现的概率
p0Vect = p0Num / p0Denom
return p0Vect, p1Vect, pAbusive
アルゴリズムのテスト: 現実的な状況に合わせて分類子を変更する
ベイジアン分類器を使用してドキュメントを分類する場合、ドキュメントが特定のカテゴリに属する確率を取得するには、複数の確率の積を計算する必要があります。つまり、p(w0|1) * p(w1|1) * p を計算します。 (w2|1)。確率値の 1 つが 0 の場合、最終積も 0 になります。この影響を軽減するには、すべての単語の出現数を 1 に初期化し、分母を 2 に初期化します (1 または 2 を取得する主な目的は、分子と分母が 0 にならないようにすることであり、次のように変更できます)ビジネスニーズ）。
発生するもう 1 つの問題はアンダーフローです。これは、非常に小さな数値を掛けすぎることによって発生します。積 p(w0|ci) * p(w1|ci) * p(w2|ci)… p(wn|ci) を計算する場合、ほとんどの因数が非常に小さいため、プログラムはアンダーフローするか、不正確な答えが得られます。(Python で非常に小さな数値を多数乗算しようとすると、最終的に 0 に丸められます)。解決策の 1 つは、積の自然対数を計算することです。代数では、ln(a * b) = ln(a) + ln(b) であるため、アンダーフローや浮動小数点の丸めによって引き起こされるエラーは、対数を求めることで回避できます。同時に、自然対数を使用しても損はありません。
以下の図は、関数 f(x) と ln(f(x)) の曲線を示しています。同じ領域で同時に増加または減少し、同じ点で極値に達することがわかります。それらの値は異なりますが、最終結果には影響しません。
def trainNB0(trainMatrix, trainCategory):
"""
训练数据优化版本
:param trainMatrix: 文件单词矩阵
:param trainCategory: 文件对应的类别
:return:
"""
# 总文件数
numTrainDocs = len(trainMatrix)
# 总单词数
numWords = len(trainMatrix[0])
# 侮辱性文件的出现概率
pAbusive = sum(trainCategory) / float(numTrainDocs)
# 构造单词出现次数列表
# p0Num 正常的统计
# p1Num 侮辱的统计
p0Num = ones(numWords)#[0,0......]->[1,1,1,1,1.....]
p1Num = ones(numWords)
# 整个数据集单词出现总数，2.0根据样本/实际调查结果调整分母的值（2主要是避免分母为0，当然值可以调整）
# p0Denom 正常的统计
# p1Denom 侮辱的统计
p0Denom = 2.0
p1Denom = 2.0
for i in range(numTrainDocs):
if trainCategory[i] == 1:
# 累加辱骂词的频次
p1Num += trainMatrix[i]
# 对每篇文章的辱骂的频次 进行统计汇总
p1Denom += sum(trainMatrix[i])
else:
p0Num += trainMatrix[i]
p0Denom += sum(trainMatrix[i])
# 类别1，即侮辱性文档的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表
p1Vect = log(p1Num / p1Denom)
# 类别0，即正常文档的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
p0Vect = log(p0Num / p0Denom)
return p0Vect, p1Vect, pAbusive
アルゴリズムを使用する: コミュニティ掲示板のコメントを分類する
単純ベイズ分類関数
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
"""
使用算法：
# 将乘法转换为加法
乘法：P(C|F1F2...Fn) = P(F1F2...Fn|C)P(C)/P(F1F2...Fn)
加法：P(F1|C)*P(F2|C)....P(Fn|C)P(C) -> log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
:param vec2Classify: 待测数据[0,1,1,1,1...]，即要分类的向量
:param p0Vec: 类别0，即正常文档的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
:param p1Vec: 类别1，即侮辱性文档的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表
:param pClass1: 类别1，侮辱性文件的出现概率
:return: 类别1 or 0
"""
# 计算公式 log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
# 大家可能会发现，上面的计算公式，没有除以贝叶斯准则的公式的分母，也就是 P(w) （P(w) 指的是此文档在所有的文档中出现的概率）就进行概率大小的比较了，
# 因为 P(w) 针对的是包含侮辱和非侮辱的全部文档，所以 P(w) 是相同的。
# 使用 NumPy 数组来计算两个向量相乘的结果，这里的相乘是指对应元素相乘，即先将两个向量中的第一个元素相乘，然后将第2个元素相乘，以此类推。
# 我的理解是：这里的 vec2Classify * p1Vec 的意思就是将每个词与其对应的概率相关联起来
p1 = sum(vec2Classify * p1Vec) + log(pClass1) # P(w|c1) * P(c1) ，即贝叶斯准则的分子
p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1) # P(w|c0) * P(c0) ，即贝叶斯准则的分子·
if p1 > p0:
return 1
else:
return 0
def testingNB():
"""
测试朴素贝叶斯算法
"""
# 1. 加载数据集
listOPosts, listClasses = loadDataSet()
# 2. 创建单词集合
myVocabList = createVocabList(listOPosts)
# 3. 计算单词是否出现并创建数据矩阵
trainMat = []
for postinDoc in listOPosts:
# 返回m*len(myVocabList)的矩阵， 记录的都是0，1信息
trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
# 4. 训练数据
p0V, p1V, pAb = trainNB0(array(trainMat), array(listClasses))
# 5. 测试数据
testEntry = ['love', 'my', 'dalmation']
thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
print testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb)
testEntry = ['stupid', 'garbage']
thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
print testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb)
プロジェクト ケース 2: Naive Bayes を使用してスパムをフィルタリングする
プロジェクト概要
Naive Bayes の最も有名なアプリケーションの 1 つである電子メール スパム フィルタリングを完了します。
開発プロセス
Naive Bayes を使用してメールを分類する
收集数据: 提供文本文件
准备数据: 将文本文件解析成词条向量
分析数据: 检查词条确保解析的正确性
训练算法: 使用我们之前建立的 trainNB() 函数
测试算法: 使用朴素贝叶斯进行交叉验证
使用算法: 构建一个完整的程序对一组文档进行分类，将错分的文档输出到屏幕上
データの収集: テキスト ファイルを提供する
テキストファイルの内容は以下のとおりです。
Hi Peter,
With Jose out of town, do you want to
meet once in a while to keep things
going and do some interesting stuff?
Let me know
Eugene
データの準備: テキスト ファイルを用語ベクトルに解析します。
正規表現を使用してテキストを分割する
>>> mySent = 'This book is the best book on Python or M.L. I have ever laid eyes upon.'
>>> import re
>>> regEx = re.compile('\\W*')
>>> listOfTokens = regEx.split(mySent)
>>> listOfTokens
['This', 'book', 'is', 'the', 'best', 'book', 'on', 'Python', 'or', 'M.L.', 'I', 'have', 'ever', 'laid', 'eyes', 'upon', '']
データの分析: 用語をチェックして、解析が正しいことを確認します。
トレーニング アルゴリズム: 以前に確立した trainNB0() 関数を使用します。
def trainNB0(trainMatrix, trainCategory):
"""
训练数据优化版本
:param trainMatrix: 文件单词矩阵
:param trainCategory: 文件对应的类别
:return:
"""
# 总文件数
numTrainDocs = len(trainMatrix)
# 总单词数
numWords = len(trainMatrix[0])
# 侮辱性文件的出现概率
pAbusive = sum(trainCategory) / float(numTrainDocs)
# 构造单词出现次数列表
# p0Num 正常的统计
# p1Num 侮辱的统计
p0Num = ones(numWords)#[0,0......]->[1,1,1,1,1.....]
p1Num = ones(numWords)
# 整个数据集单词出现总数，2.0根据样本/实际调查结果调整分母的值（2主要是避免分母为0，当然值可以调整）
# p0Denom 正常的统计
# p1Denom 侮辱的统计
p0Denom = 2.0
p1Denom = 2.0
for i in range(numTrainDocs):
if trainCategory[i] == 1:
# 累加辱骂词的频次
p1Num += trainMatrix[i]
# 对每篇文章的辱骂的频次 进行统计汇总
p1Denom += sum(trainMatrix[i])
else:
p0Num += trainMatrix[i]
p0Denom += sum(trainMatrix[i])
# 类别1，即侮辱性文档的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表
p1Vect = log(p1Num / p1Denom)
# 类别0，即正常文档的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
p0Vect = log(p0Num / p0Denom)
return p0Vect, p1Vect, pAbusive
テスト アルゴリズム: Naive Bayes を使用した相互検証
ファイル解析と完全なスパムテスト機能
# 切分文本
def textParse(bigString):
'''
Desc:
接收一个大字符串并将其解析为字符串列表
Args:
bigString -- 大字符串
Returns:
去掉少于 2 个字符的字符串，并将所有字符串转换为小写，返回字符串列表
'''
import re
# 使用正则表达式来切分句子，其中分隔符是除单词、数字外的任意字符串
listOfTokens = re.split(r'\W*', bigString)
return [tok.lower() for tok in listOfTokens if len(tok) > 2]
def spamTest():
'''
Desc:
对贝叶斯垃圾邮件分类器进行自动化处理。
Args:
none
Returns:
对测试集中的每封邮件进行分类，若邮件分类错误，则错误数加 1，最后返回总的错误百分比。
'''
docList = []
classList = []
fullText = []
for i in range(1, 26):
# 切分，解析数据，并归类为 1 类别
wordList = textParse(open('db/4.NaiveBayes/email/spam/%d.txt' % i).read())
docList.append(wordList)
classList.append(1)
# 切分，解析数据，并归类为 0 类别
wordList = textParse(open('db/4.NaiveBayes/email/ham/%d.txt' % i).read())
docList.append(wordList)
fullText.extend(wordList)
classList.append(0)
# 创建词汇表
vocabList = createVocabList(docList)
trainingSet = range(50)
testSet = []
# 随机取 10 个邮件用来测试
for i in range(10):
# random.uniform(x, y) 随机生成一个范围为 x ~ y 的实数
randIndex = int(random.uniform(0, len(trainingSet)))
testSet.append(trainingSet[randIndex])
del(trainingSet[randIndex])
trainMat = []
trainClasses = []
for docIndex in trainingSet:
trainMat.append(setOfWords2Vec(vocabList, docList[docIndex]))
trainClasses.append(classList[docIndex])
p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))
errorCount = 0
for docIndex in testSet:
wordVector = setOfWords2Vec(vocabList, docList[docIndex])
if classifyNB(array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
errorCount += 1
print 'the errorCount is: ', errorCount
print 'the testSet length is :', len(testSet)
print 'the error rate is :', float(errorCount)/len(testSet)
アルゴリズムを使用する: 一連の文書を分類し、誤って分類された文書を画面に出力するための完全なプログラムを構築します。
プロジェクト ケース 3: Naive Bayes 分類器を使用して個人広告から地域の好みを取得する
プロジェクト概要
広告主は、広告のターゲットをより適切に設定できるように、個人に関する特定の人口統計情報を知りたいと考えることがよくあります。
米国の 2 つの都市から何人かの人々を選択し、これらの人々が投稿した情報を分析して、これら 2 つの都市の人々が異なる広告言葉を使用しているかどうかを比較します。結論が実際に異なる場合、それぞれの結論に共通して使用される言葉は何でしょうか? 人々が使用する言葉から、異なる都市の人々が何を気にしているかをある程度理解できるでしょうか。
開発プロセス
收集数据: 从 RSS 源收集内容，这里需要对 RSS 源构建一个接口
准备数据: 将文本文件解析成词条向量
分析数据: 检查词条确保解析的正确性
训练算法: 使用我们之前建立的 trainNB0() 函数
测试算法: 观察错误率，确保分类器可用。可以修改切分程序，以降低错误率，提高分类结果
使用算法: 构建一个完整的程序，封装所有内容。给定两个 RSS 源，改程序会显示最常用的公共词
データの収集: RSS ソースからコンテンツを収集します。ここでは、RSS ソースのインターフェイスを構築する必要があります。
つまり、RSS フィードをインポートするには、Python を使用してテキストをダウンロードし、http://code.google.com/p/feedparser/ で関連ドキュメントを参照し、feedparse をインストールし、最初にダウンロードしたパッケージを解凍して、スイッチを実行します。解凍されたファイルが存在する現在のディレクトリに移動し、Python プロンプトで次のように入力します。
>>> python setup.py install
データの準備: テキスト ファイルを用語ベクトルに解析します。
文書バッグの言葉モデル
各単語の出現または不在を特徴として扱います。これは単語セット モデルとして記述できます。文書内に単語が複数回出現する場合、その単語が文書内に出現するかどうかでは表現できない情報が含まれている可能性があり、この手法をバッグオブワードモデルと呼びます。単語のバッグでは各単語が複数回出現する可能性がありますが、単語セットでは各単語は 1 回しか出現できません。BagOfWords2Vec() 関数は、bagOfWords2Vec() 関数を少し変更する必要があります。
Bag-of-Words モデルに基づく単純なベイズ コードを以下に示します。これは関数 setOfWords2Vec() とほぼ同じですが、唯一の違いは、単語に遭遇するたびに、対応する値を 1 に設定するのではなく、単語ベクトル内の対応する値をインクリメントすることです。
def bagOfWords2VecMN(vocaList, inputSet):
returnVec = [0] * len(vocabList)
for word in inputSet:
if word in vocaList:
returnVec[vocabList.index(word)] += 1
return returnVec
#创建一个包含在所有文档中出现的不重复词的列表
def createVocabList(dataSet):
vocabSet=set([]) #创建一个空集
for document in dataSet:
vocabSet=vocabSet|set(document) #创建两个集合的并集
return list(vocabSet)
def setOfWords2VecMN(vocabList,inputSet):
returnVec=[0]*len(vocabList) #创建一个其中所含元素都为0的向量
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)]+=1
return returnVec
#文件解析
def textParse(bigString):
import re
listOfTokens=re.split(r'\W*',bigString)
return [tok.lower() for tok in listOfTokens if len(tok)>2]
データの分析: 用語をチェックして、解析が正しいことを確認します。
トレーニング アルゴリズム: 以前に確立した trainNB0() 関数を使用します。
def trainNB0(trainMatrix, trainCategory):
"""
训练数据优化版本
:param trainMatrix: 文件单词矩阵
:param trainCategory: 文件对应的类别
:return:
"""
# 总文件数
numTrainDocs = len(trainMatrix)
# 总单词数
numWords = len(trainMatrix[0])
# 侮辱性文件的出现概率
pAbusive = sum(trainCategory) / float(numTrainDocs)
# 构造单词出现次数列表
# p0Num 正常的统计
# p1Num 侮辱的统计
# 避免单词列表中的任何一个单词为0，而导致最后的乘积为0，所以将每个单词的出现次数初始化为 1
p0Num = ones(numWords)#[0,0......]->[1,1,1,1,1.....]
p1Num = ones(numWords)
# 整个数据集单词出现总数，2.0根据样本/实际调查结果调整分母的值（2主要是避免分母为0，当然值可以调整）
# p0Denom 正常的统计
# p1Denom 侮辱的统计
p0Denom = 2.0
p1Denom = 2.0
for i in range(numTrainDocs):
if trainCategory[i] == 1:
# 累加辱骂词的频次
p1Num += trainMatrix[i]
# 对每篇文章的辱骂的频次 进行统计汇总
p1Denom += sum(trainMatrix[i])
else:
p0Num += trainMatrix[i]
p0Denom += sum(trainMatrix[i])
# 类别1，即侮辱性文档的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表
p1Vect = log(p1Num / p1Denom)
# 类别0，即正常文档的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
p0Vect = log(p0Num / p0Denom)
return p0Vect, p1Vect, pAbusive
アルゴリズムをテストします。エラー率を観察して、分類器が機能することを確認します。セグメンテーション手順を変更して、エラー率を削減し、分類結果を改善できます。
#RSS源分类器及高频词去除函数
def calcMostFreq(vocabList,fullText):
import operator
freqDict={
}
for token in vocabList: #遍历词汇表中的每个词
freqDict[token]=fullText.count(token) #统计每个词在文本中出现的次数
sortedFreq=sorted(freqDict.iteritems(),key=operator.itemgetter(1),reverse=True) #根据每个词出现的次数从高到底对字典进行排序
return sortedFreq[:30] #返回出现次数最高的30个单词
def localWords(feed1,feed0):
import feedparser
docList=[];classList=[];fullText=[]
minLen=min(len(feed1['entries']),len(feed0['entries']))
for i in range(minLen):
wordList=textParse(feed1['entries'][i]['summary']) #每次访问一条RSS源
docList.append(wordList)
fullText.extend(wordList)
classList.append(1)
wordList=textParse(feed0['entries'][i]['summary'])
docList.append(wordList)
fullText.extend(wordList)
classList.append(0)
vocabList=createVocabList(docList)
top30Words=calcMostFreq(vocabList,fullText)
for pairW in top30Words:
if pairW[0] in vocabList:vocabList.remove(pairW[0]) #去掉出现次数最高的那些词
trainingSet=range(2*minLen);testSet=[]
for i in range(20):
randIndex=int(random.uniform(0,len(trainingSet)))
testSet.append(trainingSet[randIndex])
del(trainingSet[randIndex])
trainMat=[];trainClasses=[]
for docIndex in trainingSet:
trainMat.append(bagOfWords2VecMN(vocabList,docList[docIndex]))
trainClasses.append(classList[docIndex])
p0V,p1V,pSpam=trainNBO(array(trainMat),array(trainClasses))
errorCount=0
for docIndex in testSet:
wordVector=bagOfWords2VecMN(vocabList,docList[docIndex])
if classifyNB(array(wordVector),p0V,p1V,pSpam)!=classList[docIndex]:
errorCount+=1
print 'the error rate is:',float(errorCount)/len(testSet)
return vocabList,p0V,p1V
#朴素贝叶斯分类函数
def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
p1=sum(vec2Classify*p1Vec)+log(pClass1)
p0=sum(vec2Classify*p0Vec)+log(1.0-pClass1)
if p1>p0:
return 1
else:
return 0
アルゴリズムの使用: すべてをカプセル化した完全なプログラムを構築します。2 つの RSS フィードが与えられると、プログラムは最もよく使用される一般的な単語を表示します。
関数 localWords() は 2 つの RSS ソースをパラメータとして使用します。RSS ソースは関数の外部でインポートする必要があります。これは、RSS ソースは時間の経過とともに変化し、RSS ソースを再ロードすると新しいデータが取得されるためです。
>>> reload(bayes)
<module 'bayes' from 'bayes.pyc'>
>>> import feedparser
>>> ny=feedparser.parse('http://newyork.craigslist.org/stp/index.rss')
>>> sy=feedparser.parse('http://sfbay.craigslist.org/stp/index.rss')
>>> vocabList,pSF,pNY=bayes.localWords(ny,sf)
the error rate is: 0.2
>>> vocabList,pSF,pNY=bayes.localWords(ny,sf)
the error rate is: 0.3
>>> vocabList,pSF,pNY=bayes.localWords(ny,sf)
the error rate is: 0.55
エラー率を正確に推定するには、上記の実験を複数回実行し、平均する必要があります。
次に、データを分析して地理的に関連する単語を表示する必要があります。
まずベクトル pSF と pNY を並べ替えて、順番に出力することができます。次のコードをファイルに追加します。
#最具表征性的词汇显示函数
def getTopWords(ny,sf):
import operator
vocabList,p0V,p1V=localWords(ny,sf)
topNY=[];topSF=[]
for i in range(len(p0V)):
if p0V[i]>-6.0:topSF.append((vocabList[i],p0V[i]))
if p1V[i]>-6.0:topNY.append((vocabList[i],p1V[i]))
sortedSF=sorted(topSF,key=lambda pair:pair[1],reverse=True)
print "SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**"
for item in sortedSF:
print item[0]
sortedNY=sorted(topNY,key=lambda pair:pair[1],reverse=True)
print "NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**"
for item in sortedNY:
print item[0]
関数 getTopWords() は 2 つの RSS フィードを入力として受け取り、Naive Bayes 分類器をトレーニングしてテストし、使用された確率値を返します。次に、タプルを保存するための 2 つのリストを作成します。以前の上位 X 単語の返しとは異なり、ここでは特定のしきい値を超えるすべての単語を返すことができ、これらのタプルは条件付き確率に従って並べ替えられます。
Bayes.pyファイルを保存し、Python プロンプトで次のように入力します。
>>> reload(bayes)
<module 'bayes' from 'bayes.pyc'>
>>> bayes.getTopWords(ny,sf)
the error rate is: 0.55
SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**
how
last
man
...
veteran
still
ends
late
off
own
know
NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**
someone
meet
...
apparel
recalled
starting
strings
高頻度単語を削除するコード 3 行をコメントアウトし、コメント前後の分類性能を比較したところ、コード行を削除した場合のエラー率は 54% でしたが、コードを保持した場合のエラー率は 54% でした。これらのコード行は 70% でした。ここで、これらのコメントで最も頻繁に使用される単語の上位 30 個が、使用されているすべての単語の 30% をカバーしており、vocabList のサイズは約 3000 単語であることがわかります。つまり、語彙内の単語のごく一部がテキスト A のすべてを占めています。言葉遣いの大部分。この現象が起こる理由は、言語のほとんどが冗長で構造的に補助的なものであるためです。また、所定の高頻度単語から高頻度単語だけでなく構造補助語も除去する方法が一般的であり、この語彙リストをストップワードリストと呼ぶ。
最後の単語出力から、プログラムが大量のストップ ワードを出力していることがわかります。固定されたストップ ワードを削除して結果を確認すると、分類エラー率も減少します。
要約する
分類の場合、厳密なルールを使用するよりも確率を使用する方が効果的な場合があります。ベイズ確率とベイズ基準は、既知の値を使用して未知の確率を推定する効果的な方法を提供します。
データ量の要件は、機能間の条件付き独立性を仮定することで削減できます。独立性の仮定とは、単語の確率が文書内の他の単語に依存しないことを意味します。また、この仮定は単純すぎることにも注意してください。これがナイーブベイズと呼ばれる理由です。条件付き独立性の仮定は正しくありませんが、単純ベイズは依然として有効な分類器です。
- 参照情報はApacheCNから取得されます。