NLP 设置停用词表及使用CountVectorizer计算Tf-Idf权值

NLP 设置停用词表及使用CountVectorizer计算Tf-Idf权值（7）

 为了便于理解Tf-Idf权值计算和词袋的数据结构，我们先看一个例子程序：1. 导入训练集
2. 从文件导入停用词表，并转换为list
3. 创建词袋数据结构，并配置停用词表

 

4. 统计每个词语的tf-idf权值

代码:tf-idf_test.py

1.  
2. # -*- coding: utf-8 -*-
3.  
4. import sys  
5. import os 
6. import jieba
7. from sklearn import feature_extraction  
8. from sklearn.feature_extraction.text import TfidfTransformer  
9. from sklearn.feature_extraction.text import CountVectorizer  
10.  
11. # 配置utf-8输出环境
12. reload(sys)
13. sys.setdefaultencoding('utf-8')
14.  
15. #导入训练集
16. corpus=["我 来到 北京 清华大学 了",  #第一类文本切词后的结果，词之间以空格隔开  
17.     "他 来到 了 网易 杭研 大厦",           #第二类文本的切词结果  
18.     "小明 硕士 毕业 与 中国 科学院",    #第三类文本的切词结果  
19.     "我 爱 得 北京 天安门"]                   #第四类文本的切词结果  
20.  
21. #从文件导入停用词表
22. stpwrdpath = "extra_dict/hlt_stop_words.txt"
23. stpwrd_dic = open(stpwrdpath, 'rb')
24. stpwrd_content = stpwrd_dic.read()
25. #将停用词表转换为list  
26. stpwrdlst = stpwrd_content.splitlines()
27. stpwrd_dic.close()
28.  
29. #将文本中的词语转换为词频矩阵，矩阵元素a[i][j] 表示j词在i类文本下的词频 
30. vectorizer=CountVectorizer(stop_words=stpwrdlst) #创建词袋数据结构
31. #创建hash向量词袋
32. # vectorizer = HashingVectorizer(stop_words =stpwrdlst,n_features = 10000) #设置停用词词表,设置最大维度10000
33.  
34. #统计每个词语的tf-idf权值
35. transformer = TfidfTransformer()
36. #第一个fit_transform是计算tf-idf，第二个fit_transform是将文本转为词频矩阵
37. tfidf = transformer.fit_transform(vectorizer.fit_transform(corpus))  
38. wordlist = vectorizer.get_feature_names()#获取词袋模型中的所有词  
39. # tf-idf矩阵 元素a[i][j]表示j词在i类文本中的tf-idf权重
40. weightlist = tfidf.toarray()  
41. #打印每类文本的tf-idf词语权重，第一个for遍历所有文本，第二个for便利某一类文本下的词语权重
42. for i in range(len(weightlist)):  
43.     print "-------这里输出第",i,"类文本的词语tf-idf权重------"  
44.     for j in range(len(wordlist)):  
45.         print wordlist[j],weightlist[i][j]  

复制代码

执行结果：

1.  
2. -------这里输出第 0 类文本的词语tf-idf权重------
3. 中国 0.0
4. 北京 0.52640543361
5. 大厦 0.0
6. 天安门 0.0
7. 小明 0.0
8. 来到 0.52640543361
9. 杭研 0.0
10. 毕业 0.0
11. 清华大学 0.66767854461
12. 硕士 0.0
13. 科学院 0.0
14. 网易 0.0
15. -------这里输出第 1 类文本的词语tf-idf权重------
16. 中国 0.0
17. 北京 0.0
18. 大厦 0.525472749264
19. 天安门 0.0
20. 小明 0.0
21. 来到 0.414288751166
22. 杭研 0.525472749264
23. 毕业 0.0
24. 清华大学 0.0
25. 硕士 0.0
26. 科学院 0.0
27. 网易 0.525472749264
28. -------这里输出第 2 类文本的词语tf-idf权重------
29. 中国 0.4472135955
30. 北京 0.0
31. 大厦 0.0
32. 天安门 0.0
33. 小明 0.4472135955
34. 来到 0.0
35. 杭研 0.0
36. 毕业 0.4472135955
37. 清华大学 0.0
38. 硕士 0.4472135955
39. 科学院 0.4472135955
40. 网易 0.0
41. -------这里输出第 3 类文本的词语tf-idf权重------
42. 中国 0.0
43. 北京 0.61913029649
44. 大厦 0.0
45. 天安门 0.78528827571
46. 小明 0.0
47. 来到 0.0
48. 杭研 0.0
49. 毕业 0.0
50. 清华大学 0.0
51. 硕士 0.0
52. 科学院 0.0
53. 网易 0.0
54.  

复制代码

使用 TfidfVectorizer 计算Tf-Idf权值  

代码文件: tf-idf.py
 

1.  
2. # -*- coding: utf-8 -*-
3.  
4. import sys  
5. import os 
6. import datetime
7. #引入Bunch类
8. from sklearn.datasets.base import Bunch
9. #引入持久化类
10. import pickle
11. from sklearn import feature_extraction  
12. from sklearn.feature_extraction.text import TfidfTransformer  
13. from sklearn.feature_extraction.text import CountVectorizer  
14. from sklearn.feature_extraction.text import TfidfVectorizer  
15.  
16. # 配置utf-8输出环境
17. reload(sys)
18. sys.setdefaultencoding('utf-8')
19.  
20. # 导入训练语料
21. data_set = {}  #清空原有数据集
22. # 训练语料集路径
23. train_path = "text_corpus1_wordbag/train_set.data"
24. file_obj = open(train_path, "rb")
25. #读取持久化后的对象
26. data_set = pickle.load(file_obj)
27. file_obj.close()
28. #定义词袋数据结构
29. #tdm:tf-idf计算后词袋
30. wordbag = Bunch(target_name=[],label=[],filenames=[],tdm=[],vocabulary={})
31. wordbag.target_name = data_set.target_name
32. wordbag.label = data_set.label
33. wordbag.filenames = data_set.filenames
34. # 构建语料
35. corpus = data_set.contents
36.  
37. #从文件导入停用词表
38. stpwrdpath = "extra_dict/hlt_stop_words.txt"
39. stpwrd_dic = open(stpwrdpath, 'rb')
40. stpwrd_content = stpwrd_dic.read()
41. #将停用词表转换为list  
42. stpwrdlst = stpwrd_content.splitlines()
43. stpwrd_dic.close()
44.  
45. # 计算词袋创建时间：获取开始时间
46. start = datetime.datetime.now()
47. # 使用 TfidfVectorizer初始化向量空间模型--创建词袋
48. vectorizer = TfidfVectorizer(sublinear_tf = True,max_df = 0.5,stop_words=stpwrdlst)
49. #该类会统计每个词语的tf-idf权值 
50. transformer=TfidfTransformer()
51. #文本转为词频矩阵
52. fea_train = vectorizer.fit_transform(corpus)
53.  
54. # 计算词袋时间：结束时间
55. end = datetime.datetime.now()
56. print 'create word bag peroid:',(end - start).seconds,"seconds"
57.  
58. # 计算词袋的行列数
59. print 'Size of fea_train:n',fea_train.shape  # fea_train[0:10,0:10]
60. #为tdm赋值
61. wordbag.tdm=fea_train
62. wordbag.vocabulary = vectorizer.vocabulary_
63. #创建词袋的持久化
64. file_obj = open("text_corpus1_wordbag/word_bag.data", "wb")
65. pickle.dump(wordbag,file_obj)
66. file_obj.close()
67.  

复制代码

执行结果:

1.  
2. create word bag peroid: 39 seconds
3. Size of fea_train:
4. (951, 1048576)
5.  

复制代码

 

sklearn.feature_extraction.text.CountVectorizer¶

 

class sklearn.feature_extraction.text. CountVectorizer( input=u'content',  encoding=u'utf-8', charset=None, decode_error=u'strict',  charset_error=None,  strip_accents=None,  lowercase=True,  preprocessor=None, tokenizer=None, stop_words=None,  token_pattern=u'(?u)bww+b',  ngram_range=(1,  1),  analyzer=u'word', max_df=1.0,  min_df=1, max_features=None,  vocabulary=None,  binary=False,  dtype=<type'numpy.int64'>)

 

转换一个文本集到令牌数的矩阵

这种实现产生了使用scipy.sparse.coo_matrix计数的稀疏表示

如果你没有提供一个先验的词典，并且你不使用一个特征选择的分析器，那么特征数量将等于文本提供的总词汇（vocabulary）量的大小.

 

Parameters:

input : string {‘filename’, ‘file’, ‘content’}    如果是“filename”，序列作为参数传递给拟合器，预计为文件名列表，这需要读取原始内容进行分析。    如果是“file”，序列项目必须有一个“read”的方法（类似文件的对象），被调用作为获取内存中的字节数。      否则，输入预计为序列串，或字节数据项都预计可直接进行分析。    encoding : string, ‘utf-8’ by default.    如果给出要解析的字节或文件, 编码将用于解码.    decode_error : {‘strict’, ‘ignore’, ‘replace’}    如果一个给出的字节序列包含的字符不是给定的编码，指示应该如何去做。默认情况下，它是'strict'，这意味着的UnicodeDecodeError将提高。其他值是“ignore”和“replace”。.    strip_accents : {‘ascii’, ‘unicode’, None}    在预处理步骤中去除编码规则(accents)。 “ASCII码”是一种快速的方法，仅适用于有一个直接的ASCII字符映射。 “unicode”是一个稍慢一些的方法。None（默认）什么都不做。    analyzer : string, {‘word’, ‘char’, ‘char_wb’} or callable    定义特征为词(word)或n-gram字符。选项'char_wb“仅从词边界的文本中创建n-gram字符，如果传递给它的调用被用于抽取未处理输入源文件的特征序列.    preprocessor : callable or None (default)    当保留令牌和“n-gram”生成步骤时，覆盖预处理（字符串变换）的阶段。    tokenizer : callable or None (default)    当保留预处理和n-gram生成步骤时，覆盖字符串令牌步骤。    ngram_range : tuple (min_n, max_n)    要提取的n-gram的n-values的下限和上限范围。在min_n<=n<=max_n区间的n的全部值。    stop_words : string {‘english’}, list, or None (default)    如果为'english'，用于英语内建的停用词列表。    如果为list，该列表被假定为包含停用词，列表中的所有词都将从令牌中删除。    如果为None，不使用停用词。 max_df可以被设置为范围为[0.7,1.0)的值，基于内部语料词频来自动检测和过滤停用词。    lowercase : boolean, True by default    在令牌标记前转换所有的字符为小写.    token_pattern : string    正则表达式显示了“令牌”的构成，  仅当tokenize==‘word’时才被使用。 两个或多个字母数字字符的正则表达式（标点符号完全被忽略，始终被视为一个标记分隔符）。    max_df : float in range [0.0, 1.0] or int, optional, 1.0  by default    当构建词汇时，严格忽略高于给出阈值的文档频率的词条，（语料指定的停用词）。如果是浮点值，该参数代表文档的比例，整型绝对计数值。如果词汇词典不为None，此参数被忽略.    min_df : float in range [0.0, 1.0] or int, optional, 1  by default    当构建词汇时，严格忽略低于给出阈值的文档频率的词条，（语料指定的停用词）。这个值也被称为截止文献值。如果是浮点值，该参数代表文档的比例，整型绝对计数值。如果词汇词典不为None，此参数被忽略.    max_features : optional, None by default    如果不为None,构建一个词汇表，仅考虑max_features—按语料词频排序.如果词汇表不为None，这个参数被忽略.    vocabulary : Mapping or iterable, optional    也是一个映射(Map)(例如，字典)，其中键是词条而值是在特征矩阵中索引，或词条中迭代器。如果没有给出，词汇表被确定来自输入文件。在映射中索引不能有重复，并且不能在0到最大索引值之间有间断。    binary : boolean, False by default.    如果为True，所有非零计数被设置为1，这对于离散概率模型是有用的，建立二元事件模型，而不是整型计数。    dtype : type, optional    通过fit_transform()或transform()返回矩阵的类型.

Attributes:

`vocabulary_` : dict    词条到特征索引的映射.    `stop_words_` : set    忽略出现在文件中过多（max_df）或过少（min_df）的词条。如果没有给出词汇表，这是唯一可用的。.

See also

HashingVectorizer, TfidfVectorizer

Methods

build_analyzer()	返回一个可调用的预处理和分词句柄
build_preprocessor()	返回一个函数在分词前预处理文本
build_tokenizer()	返回一个函数，分割一个字符串为连续的令牌
decode(doc)	解码输入中的Unicode的符号串
fit(raw_documents[, y])	学习原始文档中的所有令牌词汇表.
fit_transform(raw_documents[, y])	学习词汇表并且返回文件词条矩阵(term-document matrix).
get_feature_names()	一个数组映自特征整形索引到特征名称.
get_params([deep])	获取预测器的参数.
get_stop_words()	构建和抽取停止词表
inverse_transform(X)	返回文档中的词条--X中非零项.
set_params(**params)	设置预测器参数.
transform(raw_documents)	转换文档为文档词条矩阵(document-term  matrix).

__init__( input=u'content',  encoding=u'utf-8',  charset=None,  decode_error=u'strict', charset_error=None, strip_accents=None,  lowercase=True,  preprocessor=None,  tokenizer=None,  stop_words=None, token_pattern=u'(?u)bww+b',  ngram_range=(1,  1),  analyzer=u'word',  max_df=1.0,  min_df=1,  max_features=None, vocabulary=None, binary=False,  dtype=<type'numpy.int64'>)

build_analyzer()

 

返回一个可调用的预处理和分词句柄

build_preprocessor()

 

返回一个函数在令牌分词之前预处理文本

build_tokenizer()

 

返回一个函数，分割一个字符串为连续的令牌

decode( doc)

 

解码输入中的Unicode的符号串

解码策略取决于向量器参数。

fit( raw_documents,  y=None)

 

学习原始文档中的所有令牌词汇表.

Parameters:	raw_documents : iterable    一个迭代器，产生了 str, unicode 或文件对象.
Returns:	self :

fit_transform( raw_documents,  y=None)

 

学习词汇表并且返回文件词条矩阵(term-documentmatrix).

等价于拟合转换, 但更有效.

Parameters:	raw_documents : iterable    一个迭代器，产生了 str, unicode 或文件对象.
Returns:	X : array, [n_samples, n_features]    文档词条矩阵.

fixed_vocabulary

 

DEPRECATED: 使用 usefixed_vocabulary_ 代替.

get_feature_names()

 

一个数组映自特征整形索引到特征名称。

get_params( deep=True)

 

获取预测器的参数.

Parameters:	deep: boolean,  optional :    如果为True, 将返回这个预测器的参数并且包含预测器的子对象.
Returns:	params : mapping of string to any    参数名称映射到它的值.

get_stop_words()

 

构建和抽取停止词表

inverse_transform( X)

 

返回文档中的词条--X中非零项.

Parameters:	X : {array, sparse matrix}, shape = [n_samples,  n_features]
Returns:	X_inv : list of arrays, len = n_samples    项目数组列表.

set_params( **params)

 

设置预测器参数.

该方法适用于简单的估计，以及嵌套对象（如管道）。前者的格式<component>_<parameter>，以便它可以更新嵌套对象的每个组件的参数。

Returns:

self :

transform( raw_documents)

 

转换文档为文档词条矩阵.

从原始文本文件中提取令牌计数，使用合适的词汇词典，或由构造函数提供的词典。.

Parameters:	raw_documents : iterable    一个迭代器，产生了包含 str, unicode 或文件对象.
Returns:	X : sparse matrix, [n_samples, n_features]    文档词条矩阵.

 

sklearn.feature_extraction.text.TfidfTransformer class sklearn.feature_extraction.text. TfidfTransformer( norm=u'l2',  use_idf=True,  smooth_idf=True, sublinear_tf=False) 转换一个数字矩阵为归一化的 tf 或 tf-idf 表示 Tf 的含义是词频(term-frequency) ，而 tf-idf 的含义是词频乘以逆文档频率y. 这是在信息检索中通用的权重计算模式,它也能被用于文档分类中. 使用tf-idf代替文档中的词频的目的是要缩小语料库中发生非常频繁的词频的影响，因为它们比语料中文档频率较低的词汇具有更少的信息量. 实际使用的公式为 tf-idf 是 tf * (idf + 1) = tf + tf * idf, 代替 tf* idf. 这样做有助于解决idf 零值的影响, 例如. 在训练集的所有文档中都出现的词条将被忽略. 该公式可根据参数设置计算tf和idf，依据IR中的SMART概念，如下: Tf 默认是 “n” (natural) , “l” (logarithmic) 当线性tf=True. Idf 是 “t” ，当use_idf被给出, 否则为“n” (none) e. 归一化为“c” (cosine) 当=’l2’, 或为 “n”(none) 当 norm=None.    Parameters:       norm : ‘l1’, ‘l2’ or None, optional    用于归一化词向量的范数. 如不归一化为None.    use_idf : boolean, optional    启动  inverse-document-frequency 重估权重.    smooth_idf : boolean, optional    通过在文档频率中加1 平滑idf权重,阻止除0.    sublinear_tf : boolean, optional    Apply  sublinear tf scaling, i.e. replace tf with 1 + log(tf). 应用线性tf比例，即用1+log（tf）替换tf。    References    [Yates2011]       R. Baeza-Yates and B.  Ribeiro-Neto (2011). Modern Information Retrieval. Addison Wesley, pp. 68-74.         [MRS2008]       C.D. Manning, P. Raghavan  and H. Schuetze (2008). Introduction to Information Retrieval. Cambridge  University Press, pp. 118-120.    Methods fit(X[, y]) 学习 idf 向量 (全局词条权重) fit_transform(X[, y]) 拟合数据, 然后转换. get_params([deep]) 获取预测器的参数. set_params(**params) 设置预测器的参数. transform(X[, copy]) 转换计数矩阵为tf或tf-idf表示 __init__( norm=u'l2',  use_idf=True,  smooth_idf=True,  sublinear_tf=False) fit( X,  y=None) 学习 idf 向量 (全局词条权重)    Parameters:       X : sparse matrix, [n_samples, n_features]    一个词条/令牌计数矩阵    fit_transform( X,  y=None,  **fit_params) 拟合数据，然后转换. X的拟合转换器，y为可选参数fit_params ，并且返回X的转换版本.    Parameters:       X : numpy array of shape [n_samples,  n_features]    训练集.    y : numpy array of shape [n_samples]    目标值.       Returns:       X_new : numpy array of shape [n_samples,  n_features_new]    转换数组.    get_params( deep=True) 获取预测器参数.    Parameters:       deep: boolean,  optional :    如果为  True, 返回预测器的参数，包含了预测器的子对象.       Returns:       params : mapping of string to any    映射到其他值的参数名.    set_params( **params) 设置预测器参数. 该方法适用于简单的预测器，以及对嵌套对象（如管道）。前者的格式<component>__<parameter>，以便它可以更新嵌套对象的每个组件的参数。    Returns:       self :    transform( X,  copy=True) 转换一个计数矩阵为 tf 或 tf-idf 表示    Parameters:       X : sparse matrix, [n_samples, n_features]    一个词条/令牌计数矩阵       Returns:       vectors : sparse matrix, [n_samples, n_features]