精华内容
参与话题
问答
  • sklearn——CountVectorizer详解

    千次阅读 2019-06-12 11:38:43
    CountVectorizer是属于常见的特征数值计算类,是一个文本特征提取方法。对于每一个训练文本,它只考虑每种词汇在该训练文本中出现的频率。 CountVectorizer会将文本中的词语转换为词频矩阵,它通过fit_transform函数...

    转自博主啊噗不是阿婆主

    CountVectorizer是属于常见的特征数值计算类,是一个文本特征提取方法。对于每一个训练文本,它只考虑每种词汇在该训练文本中出现的频率。

    CountVectorizer会将文本中的词语转换为词频矩阵,它通过fit_transform函数计算各个词语出现的次数。

    CountVectorizer参数详解

    CountVectorizer(input='content', encoding='utf-8',  decode_error='strict', strip_accents=None, lowercase=True, preprocessor=None, tokenizer=None, stop_words=None, 
    token_pattern='(?u)\b\w\w+\b', ngram_range=(1, 1), analyzer='word', max_df=1.0, min_df=1, max_features=None, vocabulary=None, binary=False, dtype=<class 'numpy.int64'>)
    
      参数表 作用
      input 一般使用默认即可,可以设置为"filename’或’file’
      encodeing 使用默认的utf-8即可,分析器将会以utf-8解码raw document
      decode_error 默认为strict,遇到不能解码的字符将报UnicodeDecodeError错误,设为ignore将会忽略解码错误,还可以设为replace,作用尚不明确
      strip_accents 默认为None,可设为ascii或unicode,将使用ascii或unicode编码在预处理步骤去除raw document中的重音符号
      analyzer 一般使用默认,可设置为string类型,如’word’, ‘char’, ‘char_wb’,还可设置为callable类型,比如函数是一个callable类型
      preprocessor 设为None或callable类型
      tokenizer 设为None或callable类型
      ngram_range 词组切分的长度范围,待详解
      stop_words 设置停用词,设为english将使用内置的英语停用词,设为一个list可自定义停用词,设为None不使用停用词,设为None且max_df∈[0.7, 1.0)将自动根据当前的语料库建立停用词表
      lowercase 将所有字符变成小写
      token_pattern 过滤规则,表示token的正则表达式,需要设置analyzer == ‘word’,默认的正则表达式选择2个及以上的字母或数字作为token,标点符号默认当作token分隔符,而不会被当作token
      max_df 可以设置为范围在[0.0 1.0]的float,也可以设置为没有范围限制的int,默认为1.0。这个参数的作用是作为一个阈值,当构造语料库的关键词集的时候,如果某个词的document frequence大于max_df,这个词不会被当作关键词。如果这个参数是float,则表示词出现的次数与语料库文档数的百分比,如果是int,则表示词出现的次数。如果参数中已经给定了vocabulary,则这个参数无效
      min_df 类似于max_df,不同之处在于如果某个词的document frequence小于min_df,则这个词不会被当作关键词
      max_features 默认为None,可设为int,对所有关键词的term frequency进行降序排序,只取前max_features个作为关键词集
      vocabulary 默认为None,自动从输入文档中构建关键词集,也可以是一个字典或可迭代对象?
      binary 默认为False,一个关键词在一篇文档中可能出现n次,如果binary=True,非零的n将全部置为1,这对需要布尔值输入的离散概率模型的有用的
      dtype 使用CountVectorizer类的fit_transform()或transform()将得到一个文档词频矩阵,dtype可以设置这个矩阵的数值类型
      属性表 作用
      vocabulary_ 词汇表;字典型
      get_feature_names() 所有文本的词汇;列表型
      stop_words_ 返回停用词表
      方法表 作用
      fit_transform(X) 拟合模型,并返回文本矩阵
      fit(raw_documents[, y]) Learn a vocabulary dictionary of all tokens in the raw documents.
      fit_transform(raw_documents[, y]) Learn the vocabulary dictionary and return term-document matrix.
      • 用数据输入形式为列表,列表元素为代表文章的字符串,一个字符串代表一篇文章,字符串是已经分割好的。CountVectorizer同样适用于中文;
      • CountVectorizer是通过fit_transform函数将文本中的词语转换为词频矩阵,矩阵元素a[i][j] 表示j词在第i个文本下的词频。即各个词语出现的次数,通过get_feature_names()可看到所有文本的关键字,通过toarray()可看到词频矩阵的结果。

      入门示例

      from sklearn.feature_extraction.text import CountVectorizer
      
      texts=["dog cat fish","dog cat cat","fish bird", 'bird'] # “dog cat fish” 为输入列表元素,即代表一个文章的字符串
      cv = CountVectorizer()#创建词袋数据结构
      cv_fit=cv.fit_transform(texts)
      #上述代码等价于下面两行
      #cv.fit(texts)
      #cv_fit=cv.transform(texts)
      
      print(cv.get_feature_names())    #['bird', 'cat', 'dog', 'fish'] 列表形式呈现文章生成的词典
      
      print(cv.vocabulary_	)              # {‘dog’:2,'cat':1,'fish':3,'bird':0} 字典形式呈现,key:词,value:词频
      
      print(cv_fit)
      # (0,3) 1   第0个列表元素,**词典中索引为3的元素**, 词频
      #(0,1)1
      #(0,2)1
      #(1,1)2
      #(1,2)1
      #(2,0)1
      #(2,3)1
      #(3,0)1
      
      print(cv_fit.toarray()) #.toarray() 是将结果转化为稀疏矩阵矩阵的表示方式;
      #[[0 1 1 1]
      # [0 2 1 0]
      # [1 0 0 1]
      # [1 0 0 0]]
      
      print(cv_fit.toarray().sum(axis=0))  #每个词在所有文档中的词频
      #[2 3 2 2]
      

      设置停用词列表,处理中文文档

      #从文件导入停用词表
      stpwrdpath ="C:\\Users\\Administrator\Desktop\lect09_codes\lect09_proj\stop_words\\中文停用词库.txt"
      with open(stpwrdpath, 'rb') as fp:
          stopword = fp.read().decode('utf-8')  # 提用词提取
      #将停用词表转换为list  
      stpwrdlst = stopword.splitlines()
      # 从sklearn.feature_extraction.text里导入CountVectorizer
      from sklearn.feature_extraction.text import CountVectorizer
      # 对CountVectorizer进行初始化(去除中文停用词)
      count_vec=CountVectorizer(stop_words=stpwrdlst) #创建词袋数据结构
      X_count_train = count_vec.fit_transform(all_list[:2])  #<class 'scipy.sparse.csr.csr_matrix'>
      # 将原始训练和测试文本转化为特征向量
      X_count_train= X_count_train.toarray()
      X_count_test = count_vec.transform(all_list[2]).toarray()
      print(X_count_train)
      #词汇表
      print('\nvocabulary list:\n\n',count_vec.get_feature_names())
      print( '\nvocabulary dic :\n\n',count_vec.vocabulary_)
      print ('vocabulary:\n\n')
      for key,value in count_vec.vocabulary_.items():
          print(key,value)
      

      训练集也就是a,b 的词频统计结果,词汇列表、字典为:

      [[1 1 1 1 1 0 0 2 1 0 1 1 1 0 1 0 0 0 1 0 1 1 0 3 1 2 0 0 1 0 0 1 1 1 2]
       [0 0 0 0 0 1 1 1 1 1 0 0 0 1 1 1 1 1 0 1 3 0 1 4 0 0 1 1 1 1 1 0 1 1 1]]
      
      vocabulary list:
      
       ['一个', '一体', '一门', '之间', '人工智能', '使用', '区别', '处理', '实现', '密切', '数学', '方向', '方法', '日常', '有效', '有着', '涉及', '特别', '理论', '研制', '研究', '科学', '联系', '自然语言', '计算机', '计算机科学', '计算机系统', '语言', '语言学', '软件系统', '这一', '进行', '通信', '重要', '领域']
      
      vocabulary dic :
      
       {'区别': 6, '特别': 17, '一体': 1, '数学': 10, '方法': 12, '方向': 11, '计算机科学': 25, '研制': 19, '涉及': 16, '实现': 8, '日常': 13, '有着': 15, '语言学': 28, '这一': 30, '重要': 33, '人工智能': 4, '进行': 31, '理论': 18, '一门': 2, '自然语言': 23, '有效': 14, '通信': 32, '研究': 20, '联系': 22, '使用': 5, '科学': 21, '软件系统': 29, '计算机系统': 26, '领域': 34, '计算机': 24, '密切': 9, '之间': 3, '语言': 27, '一个': 0, '处理': 7}
      vocabulary:
      
      
      区别 6
      特别 17
      一体 1
      数学 10
      方法 12
      方向 11
      计算机科学 25
      研制 19
      涉及 16
      实现 8
      日常 13.....
      

      (1) 停用词的配置:也可默认配置count_vec=CountVectorizer(stop_words=None) ,stop_words=None表示不去掉停用词;如果是英文的话,停用词不需要构建直接 count_vec=CountVectorizer(stop_words=’english’)则去掉英语停用词

      (2)count_vec.fit_transform(data)的结果是如下的格式:

      print(count_vec.fit_transform(X_test))
       (0:data输入列表的元素索引(第几个文章(列表元素)),词典里词索引)  词频
        (0, 7)    2
        (0, 25)   2
        (0, 34)   2
        (0, 4)    1
        (0, 0)    1
        ......
      print(count_vec.fit_transform(X_test).toarray())
      [[1 1 1 1 1 0 0 2 1 0 1 1 1 0 1 0 0 0 1 0 1 1 0 3 1 2 0 0 1 0 0 1 1 1 2]
       [0 0 0 0 0 1 1 1 1 1 0 0 0 1 1 1 1 1 0 1 3 0 1 4 0 0 1 1 1 1 1 0 1 1 1]]
      
      • 属性:
        vocabulary_:字典类型,key为关键词,value是特征索引,样例如下:
        com.furiousapps.haunt2: 57048
        bale.yaowoo: 5025
        asia.share.superayiconsumer: 4660
        com.cooee.flakes: 38555
        com.huahan.autopart: 67364
        关键词集被存储为一个数组向量的形式,vocabulary_中的key是关键词,value就是该关键词在数组向量中的索引,使用get_feature_names()方法可以返回该数组向量。使用数组向量可验证上述关键词,如下:
      ipdb> count_vec.get_feature_names()[57048]
      # 返回u'com.furiousapps.haunt2'
      ipdb> count_vec.get_feature_names()[5025]
      # 返回u'bale.yaowoo'
      
    • stop_words_:集合类型,官网的解释十分到位,如下:
      Terms that were ignored because they either:
      occurred in too many documents (max_df)
      occurred in too few documents (min_df)
      were cut off by feature selection (max_features).
      This is only available if no vocabulary was given.
      这个属性一般用来程序员自我检查停用词是否正确,在pickling的时候可以设置stop_words_为None是安全的。
    • 参考如下链接整理:
      http://stackoverflow.com/questions/27488446/scikit-learn-countvectorizer
      http://www.itkeyword.com/doc/4813494854317445586/TfidfVectorizer-sklearn-CountVectorizer
      这个链接写的很棒,主要参考他的:
      https://blog.csdn.net/Datawhale/article/details/82317529

      展开全文
    • CountVectorizer()函数 CountVectorizer()函数只考虑每个单词出现的频率;然后构成一个特征矩阵,每一行表示一个训练文本的词频统计结果。其思想是,先根据所有训练文本,不考虑其出现顺序,只将训练文本中每个出现...

      CountVectorizer()函数

      CountVectorizer()函数只考虑每个单词出现的频率;然后构成一个特征矩阵,每一行表示一个训练文本的词频统计结果。其思想是,先根据所有训练文本,不考虑其出现顺序,只将训练文本中每个出现过的词汇单独视为一列特征,构成一个词汇表(vocabulary list),该方法又称为词袋法(Bag of Words)

      我们举一个例子:

      from sklearn.feature_extraction.text import CountVectorizer,TfidfVectorizer
      
      texts=["orange banana apple grape","banana apple apple","grape", 'orange apple'] 
      cv = CountVectorizer()
      cv_fit=cv.fit_transform(texts)
      print(cv.vocabulary_)
      print(cv_fit)
      print(cv_fit.toarray())

      输出如下:

      {'orange': 3, 'banana': 1, 'apple': 0, 'grape': 2} #这里是根据首字母顺序,将texts变量中所有单词进行排序,apple首字母为a所以                                                                          # 排第一,banana首字母为b所以排第二
        (0, 2)    1   # (0, 2)  1 中0表示第一个字符串"orange banana apple grape";2对应上面的'grape': 2;1表示出现次数1。整体理                       # 解为第一字符串顺序为二的词语在出现次数为1
        (0, 0)    1
        (0, 1)    1
        (0, 3)    1
        (1, 0)    2
        (1, 1)    1
        (2, 2)    1
        (3, 0)    1
        (3, 3)    1
      [[1 1 1 1]     # 第一个字符串,排名0,1,2,3词汇(apple,banana,grape,orange)出现的频率都为1
       [2 1 0 0]    #第二个字符串,排名0,1,2,3词汇(apple,banana,grape,orange)出现的频率为2,1,00
       [0 0 1 0]
       [1 0 0 1]]

      TfidfVectorizer()函数

      TfidfVectorizer()基于tf-idf算法。此算法包括两部分tf和idf,两者相乘得到tf-idf算法。

      tf算法统计某训练文本中,某个词的出现次数,计算公式如下:

       或 

      idf算法,用于调整词频的权重系数,如果一个词越常见,那么分母就越大,逆文档频率就越小越接近0。

      tf-idf算法=tf算法 * idf算法。

      我们依旧采用上面的例子:

      from sklearn.feature_extraction.text import CountVectorizer,TfidfVectorizer
      
      texts=["orange banana apple grape","banana apple apple","grape", 'orange apple']
      cv = TfidfVectorizer()
      cv_fit=cv.fit_transform(texts)
      print(cv.vocabulary_)
      print(cv_fit)
      print(cv_fit.toarray())

       

      输出如下:

      {'orange': 3, 'banana': 1, 'apple': 0, 'grape': 2}
        (0, 3)    0.5230350301866413 #(0,3)表示第一个字符串的orange词语,其TF=1/4,IDF中总样本和包含有改词的文档数,目                                                    # 前也不知道是如何得出,望有知道的人能评论告之。最后得出结果0.5230350301866413
        (0, 1)    0.5230350301866413
        (0, 0)    0.423441934145613
        (0, 2)    0.5230350301866413
        (1, 1)    0.5254635733493682
        (1, 0)    0.8508160982744233
        (2, 2)    1.0
        (3, 3)    0.7772211620785797
        (3, 0)    0.6292275146695526
      [[0.42344193 0.52303503 0.52303503 0.52303503]
       [0.8508161  0.52546357 0.         0.        ]
       [0.         0.         1.         0.        ]
       [0.62922751 0.         0.         0.77722116]]

      展开全文
    • 这里使用的是原始的词频统计,所有词的权重是相等的。

      CountVectorizer

      • 将文本文档集合转换为令牌计数矩阵
      • 此实现生成使用的计数的稀疏表示
      • 如果不提供先验字典,也不使用分析器这做了一些特征选择然后特征的数量会等于通过分析数据发现的词汇量
      # 从sklearn的特征工程的文本模块导入词频统计函数
      from sklearn.feature_extraction.text import CountVectorizer
      # 该统计方法认为所有词的权重是相等的,在具有大量词汇的文本分类中表现不佳
      '''
      # 参数
      @ input:
      	string {'filename', 'file', 'content'}
      	如果“filename”,则作为要匹配的参数传递的序列为
      	期望是需要读取才能获取的文件名列表
      	要分析的原始内容。
      	如果是file,序列项必须有一个read方法(类似于file)
      	对象),它被调用来获取内存中的字节。
      	否则,预期输入为序列字符串或
      	字节项将被直接分析。
      @ encoding:
      	string, 'utf-8' by default.
      	如果要分析字节或文件,则使用这种编码解码
      @ lowercase:
      	boolean, True by default
      	在标记之前将所有字符转换为小写
      @ tokenizer:
      	callable or None (default)
      	覆盖字符串标记化步骤,同时保留预处理和n-g生成步骤。
      	仅当' ' analyzer == 'word' ' '时才适用
      @ stop_words:
      	string {'english'}, list, or None (default)
      	如果是“english”,则使用一个内置的英语停止词列表。
      	“英语”有几个众所周知的问题,你应该注意
      	考虑另一种方法(参见:ref: ' stop_words ')。
      	如果是列表,则假定该列表包含停止字,所有这些都包含
      	将从生成的令牌中删除。
      	仅当' ' analyzer == 'word' ' '时才适用。
      	如果没有,则不会使用停止词。max_df可以设置为一个值
      	在[0.7,1.0]范围内自动检测和过滤停止
      	基于语料库内部词汇文档频率的词汇。
      @ token_pattern : 
      	string
      	正则表达式,仅用于表示构成“令牌”的内容
      	如果' ' analyzer == 'word' ' '。默认的regexp选择令牌为2
      	或更多的字母数字字符(标点符号完全被忽略
      	并始终被视为令牌分隔符)。
      @ max_df:
      	浮动范围[0.0,1.0]或int,默认值为1.0
      	在构建词汇表时,忽略具有文档的词汇
      	频率严格高于给定的阈值(特定于微粒)
      	停止词)。
      	如果是浮点数,则该参数表示文档的比例整数
      	绝对计数。
      	如果词汇表不是None,则忽略此参数。
      @ min_df:
      	浮动范围[0.0,1.0]或int,默认值为1
      	在构建词汇表时,忽略具有文档的词汇
      	频率严格低于给定的阈值。这个值也是
      	在文献中称为截断。
      	如果是浮点数,则该参数表示文档的比例整数
      	绝对计数。
      	如果词汇表不是None,则忽略此参数。
      @ max_features: 
      	int或None, default=None
      	如果没有的话,建立一个只考虑顶部的词汇表
      	max_features按词频在语料库中排序。
      	如果词汇表不是None,则忽略此参数。
      '''
      
      '''
      # Attributes 属性
      @ vocabulary_: 
      	dict类型
      	术语到特征索引的映射。
      @ stop_words_:
      	集合类型
      	被忽略的术语,因为它们要么:
      	-出现在太多文档中(' max_df ')
      	-文件太少(' min_df ')
      	-被功能选择切断(' max_features ')。
      	只有在没有提供词汇表的情况下才可用。
      '''
      

      典型例题数据

      Y,words
      1,Chinese Beijing Chinese
      1,Chinese Chinese Shanghai
      1,Chinese Macao
      0,Tokyo Japan Chinese
      # 预测数据为['Chinese Chinese Chinese Tokyo Japan']
      

      代码如下

      '''
          Y,words
          1,Chinese Beijing Chinese
          1,Chinese Chinese Shanghai
          1,Chinese Macao
          0,Tokyo Japan Chinese
      '''
      
      import pandas as pd
      # 从sklearn的特征工程的文本模块导入词频统计函数
      from sklearn.feature_extraction.text import CountVectorizer
      # 导入多分类贝叶斯
      from sklearn.naive_bayes import MultinomialNB
      
      # 读取数据
      df = pd.read_csv("../datas/bayes_xinxi.txt")
      # 建立词频统计模型token_pattern="[a-zA-Z|\u4e00-\u9fa5]+"正则表达式表示以单词或一个中文分词
      tfCoder = CountVectorizer(token_pattern="[a-zA-Z|\u4e00-\u9fa5]+")
      # 提取次样本
      X = df["words"]
      # 提取标签类别
      Y = df["Y"]
      X = tfCoder.fit_transform(X)
      print(tfCoder.get_feature_names())
      print(X.toarray())
      
      # 建立贝叶斯模型
      model = MultinomialNB()
      model.fit(X,Y)
      
      # 需要预测的数据
      T = ['Chinese Chinese Chinese Tokyo Japan']
      # 把T编码 再预测
      print(model.predict(tfCoder.transform(T)))
      
      # 效果如下
      
      # 词表
      ['beijing', 'chinese', 'japan', 'macao', 'shanghai', 'tokyo']
      # 词频统计
      [[1 2 0 0 0 0]
       [0 2 0 0 1 0]
       [0 1 0 1 0 0]
       [0 1 1 0 0 1]]
      # 预测结果
      [1]
      
      展开全文
    • 实现一个CountVectorizer

      千次阅读 2018-05-18 17:20:59
      实现一个CountVectorizer   最近在一个nlp问题中使用了sklearn的CountVectorizer库进行分词,目的是对一个多值离散型特征进行编码并转换成稀疏矩阵(csr_matrix),使用过程中发现CountVectorizer的速度非常慢,...

      实现一个CountVectorizer

        最近在一个nlp问题中使用了sklearn的CountVectorizer库进行分词,目的是对一个多值离散型特征进行编码并转换成稀疏矩阵(csr_matrix),使用过程中发现CountVectorizer的速度非常慢,相当的耗时,因此决定提取最核心的功能,实现一个自己的版本,只要能实现相同的功能并更加节省时间即可。

      提取CountVectorizer的功能

        我需要实现的只有两个函数,fittransform。为了准确实现自己的版本,我首先需要分析CountVectorizer中这两个函数的功能。
        对于一个由字符串构成的数组,每个元素可能是一个以空格分割的句子(sentence),CountVectorizer.fit的功能是将它们分割,为每一个单词(word)编码,在这个过程中会自动滤除停止词(stop words),例如英文句子中的”a”,”.”之类的长度为1的字符串。CountVectorizer.transform的功能则是将输入的数组中每个元素进行分割,然后使用fit中生成的编码字典,将原单词转化成编码,数据以csr_matrix的形式返回。


      自己实现的版本

      # coding:utf-8
      import numpy as np
      from scipy import sparse
      
      class MyCountVectorizer():
          def __init__(self, pass_stop=True):
              self.pass_stop = pass_stop # 提供停止词滤除功能,可禁止
      
          def fit(self, data):
              data = map(lambda x:str(x).split(" "), data)
              self.elements_ = set()
              for line in data:
                  for x in line:
                      if self.pass_stop:
                          if len(x)==1:
                              continue
                      self.elements_.add(x)
              # 原元素
              self.elements_ = np.sort(list(self.elements_))
              # 编码
              self.labels_ = np.arange(len(self.elements_)).astype(int)
              # 生成字典
              self.dict_ = {}
              for i in range(len(self.elements_)):
                  self.dict_[str(self.elements_[i])] = self.labels_[i]
      
          def transform(self, data):
              rows = []
              cols = []
              data = map(lambda x:str(x).split(" "), data)
              for i in range(len(data)):
                  for x in data[i]:
                      if self.pass_stop:
                          if len(x)==1:
                              continue
                      rows.append(i)
                      cols.append(self.dict_[x])
              vals = np.ones((len(rows),)).astype(int)
      
              return sparse.csr_matrix((vals, (rows, cols)), shape=(len(data), len(self.labels_)))

      为什么vals可以直接用ones

        可能有人会有疑问,如果一个句子中有两个相同的单词怎么办?例如”one two one”,实际上sparse.csc_matrix遇到相同两个相同位置的记录,会自动将值进行累加。为了解释这个问题,我再做一个实验,如下所示,这是一个对角矩阵的稀疏表达,在对角线上的值原本都是1,但是我把坐标(2,2)上的值重复了一次。

      from scipy import sparse
      
      rows = [0,1,2,2]
      cols = [0,1,2,2]
      vals = [1,1,1,1]
      mat = sparse.csr_matrix((vals,(rows,cols)), shape=(3,3))
      print mat.toarray()

      结果如下,可见对位置重复的记录,sparse.csr_matrix会自动累加到数值上。

      [[1 0 0]
       [0 1 0]
       [0 0 2]]

      时间性能测试

        接下来应该测试一下我的版本是否能达到要求,即既能准确计算,又能节省时间。test.csv是我伪造的一个数据集,对它简单进行重复,分别统计两种方法的时间,同时获取两者生成的数据结果,做差保证两者一致。

      from sklearn.feature_extraction.text import CountVectorizer
      import pandas as pd
      from scipy import sparse
      from MyCountVectorizer import MyCountVectorizer
      import time
      import numpy as np
      from matplotlib import pyplot as plt
      
      data = pd.read_csv("data/test.csv")
      
      records = []
      for n in range(100, 10100, 100):
          seq = np.tile(data['interest'].values, (n,1)).ravel()
      
          # CountVectorizer in sklearn
          start1 = time.time()
          cv = CountVectorizer()
          cv.fit(seq)
          res1 = cv.transform(seq).toarray()
          end1 = time.time()
      
          # MyCountVectorizer
          start2 = time.time()
          mcv = MyCountVectorizer()
          mcv.fit(seq)
          res2 = mcv.transform(seq).toarray()
          end2 = time.time()
      
          # 保证两种方法生成的结果一致
          assert np.sum(res1-res2) == 0
      
          records.append((n, end1-start1, end2-start2))
      records = np.array(records)
      
      plt.plot(records[:,0], records[:,1], label="CountVectorizer")
      plt.plot(records[:,0], records[:,2], label="MyCountVectorizer")
      plt.legend()
      plt.savefig('pictures/result.png')

      这里写图片描述

      可见,我的版本既节省时间,计算得到的结果也与sklearn的版本一致。

      完整的代码在:https://github.com/SongDark/MyCountVectorizer


      参考资料

      【API】scipy.sparse.csr_matrix
      【API】sklearn.feature_extraction.text.CountVectorizer
      【StackOverFlow】CountVectorizer: AttributeError: ‘numpy.ndarray’ object has no attribute ‘lower’

      展开全文
    • CountVectorizer(input='content', encoding='utf-8', decode_error='strict', strip_accents=None, lowercase=True, preprocessor=None, tokenizer=None, stop_words=None, token_pattern='(?u)\b\w\w+\b', ngram_...
    • CountVectorizer

      千次阅读 2017-12-07 00:00:00
      CountVectorizer 关于文本特征提取,前面一篇文章TF-IDF介绍了HashingTF,本文将再介绍一种Spark MLlib的API CountVectorizerCountVectorizer 和 CountVectorizerModel 旨在帮助将文本文档集合转化为频数向量...
    • CountVectorizer 词频统计

      千次阅读 2019-06-27 20:06:10
      from sklearn.feature_extraction.text import CountVectorizer import jieba # 实例化一个con_vec对象 # con_vec = CountVectorizer(min_df=1) # 准备文本数据 # text = ['This is the first document.', 'This ...
    • Python 文本特征提取 DictVectorizer CountVectorizer TfidfVectorizer 文本特征提取:将文本数据转化成特征向量的过程。 python-sklearn库的模块 sklearn.feature_extraction 可用于提取符合机器学习算法支持的特征...
    • 文本特征提取词袋(Bag of Words)表征文本分析是机器学习算法的主要应用领域。但是,文本分析的原始数据无法直接丢给算法,这些原始数据是一组符号,因为大多数算法期望的输入是固定长度的数值特征向量而不是不同...
    • One-hot 这里的One-hot与数据挖掘任务中的操作是一致的,即将每一个单词使用一个离散的向量表示。具体将每个字/词编码一个索引,然后根据索引进行赋值。 One-hot表示方法的例子如下: 句子1:我 爱 北 京 天 安 ...
    • 1. 数据预处理import pandas as pd import numpy as np import jieba import re # 1....gcd1_df = pd.read_csv('G:\\自学笔记\\学习笔记:Python数据分析--玩转文本挖掘\\PythonData\\鬼吹灯之精绝古城txt全本精校版....
    • 上一篇博客shuihupo 博客地址,https://blog.csdn.net/shuihupo/article/details/80923414 shuihupo对字典储存的的数据,我们使用CountVectorizer对特征进行抽取和向量化。 在文本数据处理中,我们遇到的经常是一个...
    • 文本数据预处理的第一步通常是进行分词,分词后会进行向量化的操作。在介绍向量化之前,我们先来了解下词袋模型。   1.词袋模型(Bag of words,简称 BoW )    词袋模型假设我们不考虑文本中词与词之间的上...
    • Tf-idfVectorizer 与CountVectorizer详解 1 机器学习文本分类 机器学习是对能通过经验自动改进的计算机算法的研究。机器学习通过历史数据训练出模型对应于人类对经验进行归纳的过程,机器学习利用模型对新数据进行...
    • Spark MLlib 提供三种文本特征提取方法,分别为TF-IDF、Word2Vec以及CountVectorizer其各自原理与调用代码整理如下: TF-IDF 算法介绍:  词频-逆向文件频率(TF-IDF)是一种在文本挖掘中广泛使用的特征向量...
    • 初步想法是利用n-gram方法,因此查询到了python的sklearn中有一个CountVectorizer方法可以使用,在这里介绍一下这个函数的使用方法,以及其输出的相关含义。 0x01 输入及输出 from sklearn.feature_extraction....
    • from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer CountVectorize CountVectorizer是特征数值计算类,是一个文本特征提取方法。对于每一个训练文本,它只考虑每种词汇在该训练文本中...
    • 本人小白一枚,现在正在做分词和文本挖掘的事情,翻译了下sklearn.feature_extraction.text.CountVectorizer,有错误之处还请大佬指出   将文本文档集合转换为计数矩阵此实现使用scipy.sparse.csr_matrix生成计数...
    • <template> <countTo :startVal="startVal" :endVal="endVal" :duration="3000">...import countTo from "vue-count-to"; export default { components: { countTo }, data() { return { startVa
    • 构建词向量简单的有两种分别是TfidfTransformer和 CountVectorizer,这里探索一下他们的使用方法 第一种使用方法,先使用CountVectorizer对原始文本数据进行处理,转换成各个词的频率,没有出现的就是0(这里需要注意的...
    • sklearn函数CountVectorizer()和TfidfVectorizer()计算方法介绍 CountVectorizer()函数 CountVectorizer()函数只考虑每个单词出现的频率;然后构成一个特征矩阵,每一行表示一个训练文本的词频统计结果。其思想是,...
    • data,csv 代码实现: from sklearn.model_selection import train_test_split from sklearn.naive_bayes import MultinomialNB #采用...from sklearn.feature_extraction.text import CountVectorizer # 从sklearn...
    • CountVectorizer文本特征提取

      千次阅读 2018-05-21 10:44:45
      om sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer, TfidfTransformer corpus = [ 'This is the first document.', 'This is the second second document.', 'And the third...
    • MySQL count去重并包括null

      万次阅读 2020-06-14 10:05:31
      版本 mysql 5.7.20 去重聚合获取count值 SELECT count(DISTINCT(字段)) FROM 表 带null去重聚合count值 SELECT count(DISTINCT(IFNULL(字段,1))) FROM 表
    • #学习目标1:使用CountVectorizer和TfidfVectorizer对非结构化的符号化数据(如一系列字符串)进行特征抽取和向量化 from sklearn.datasets import fetch_20newsgroups #从互联网上即时下载新闻样本,subset = 'all'...
    • 一、数据集介绍 20 newsgroups数据集18000篇新闻文章,一共涉及到20种话题,所以称作20 newsgroups text dataset,分文两部分:训练集和测试集,通常用来做文本分类。sklearn提供了该数据的接口:sklearn.datasets....
    • 1、CountVectorizer 设我们有N个文档。 CountVectorizer首先统计这N个文档中除stop_words之外所出现过的词,生成一个词汇表(设词汇表为V,其长度为|V|)。...from sklearn.feature_extraction.text import Count...
    • 1.CountVectorizer() 这个函数的作用是:生产 文档 - 词频 矩阵,如: 1.1 导入 from sklearn.feature_extraction.text import CountVectorizer,TfidfVectorizer 1.2 调用 实例化 #只列出常用的参数 contv = ...
    • 最近做文本文档分类,用sklearnli
    • CountVectorizer是属于常见的特征数值计算类,是一个文本特征提取方法。对于每一个训练文本,它只考虑每种词汇在该训练文本中出现的频率。 CountVectorizer会将文本中的词语转换为词频矩阵,它通过fit_transform函数...

    空空如也

    1 2 3 4 5 ... 20
    收藏数 2,605,849
    精华内容 1,042,339
    关键字:

    countvectorizer