用Python给文本创立向量空间模型的教程

我们需要开始思考如何将文本集合转化为可量化的东西。最简单的方法是考虑词频。

我将尽量尝试不使用NLTK和Scikits-Learn包。我们首先使用Python讲解一些基本概念。

基本词频

首先,我们回顾一下如何得到每篇文档中的词的个数:一个词频向量。

#examples taken from here: http://stackoverflow.com/a/1750187

mydoclist = ['Julie loves me more than Linda loves me',
'Jane likes me more than Julie loves me',
'He likes basketball more than baseball']

#mydoclist = ['sun sky bright', 'sun sun bright']

from collections import Counter

for doc in mydoclist:
  tf = Counter()
  for word in doc.split():
    tf[word] +=1
  print tf.items()

[('me', 2), ('Julie', 1), ('loves', 2), ('Linda', 1), ('than', 1), ('more', 1)]
[('me', 2), ('Julie', 1), ('likes', 1), ('loves', 1), ('Jane', 1), ('than', 1), ('more', 1)]
[('basketball', 1), ('baseball', 1), ('likes', 1), ('He', 1), ('than', 1), ('more', 1)]

这里我们引入了一个新的Python对象,被称作为Counter。该对象只在Python2.7及更高的版本中有效。Counters非常的灵活,利用它们你可以完成这样的功能:在一个循环中进行计数。

根据每篇文档中词的个数,我们进行了文档量化的第一个尝试。但对于那些已经学过向量空间模型中“向量”概念的人来说,第一次尝试量化的结果不能进行比较。这是因为它们不在同一词汇空间中。

我们真正想要的是,每一篇文件的量化结果都有相同的长度,而这里的长度是由我们语料库的词汇总量决定的。

import string #allows for format()

def build_lexicon(corpus):
  lexicon = set()
  for doc in corpus:
    lexicon.update([word for word in doc.split()])
  return lexicon

def tf(term, document):
 return freq(term, document)

def freq(term, document):
 return document.split().count(term)

vocabulary = build_lexicon(mydoclist)

doc_term_matrix = []
print 'Our vocabulary vector is [' + ', '.join(list(vocabulary)) + ']'
for doc in mydoclist:
  print 'The doc is "' + doc + '"'
  tf_vector = [tf(word, doc) for word in vocabulary]
  tf_vector_string = ', '.join(format(freq, 'd') for freq in tf_vector)
  print 'The tf vector for Document %d is [%s]' % ((mydoclist.index(doc)+1), tf_vector_string)
  doc_term_matrix.append(tf_vector)

  # here's a test: why did I wrap mydoclist.index(doc)+1 in parens? it returns an int...
  # try it! type(mydoclist.index(doc) + 1)

print 'All combined, here is our master document term matrix: '
print doc_term_matrix

我们的词向量为[me, basketball, Julie, baseball, likes, loves, Jane, Linda, He, than, more]

文档”Julie loves me more than Linda loves me”的词频向量为:[2, 0, 1, 0, 0, 2, 0, 1, 0, 1, 1]

文档”Jane likes me more than Julie loves me”的词频向量为:[2, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1]

文档”He likes basketball more than baseball”的词频向量为:[0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1]

合在一起,就是我们主文档的词矩阵:

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

好吧,这看起来似乎很合理。如果你有任何机器学习的经验,你刚刚看到的是建立一个特征空间。现在每篇文档都在相同的特征空间中,这意味着我们可以在同样维数的空间中表示整个语料库,而不会丢失太多信息。

标准化向量,使其L2范数为1

一旦你在同一个特征空间中得到了数据,你就可以开始应用一些机器学习方法:分类、聚类等等。但实际上,我们同样遇到一些问题。单词并不都包含相同的信息。

如果有些单词在一个单一的文件中过于频繁地出现,它们将扰乱我们的分析。我们想要对每一个词频向量进行比例缩放,使其变得更具有代表性。换句话说,我们需要进行向量标准化。

我们真的没有时间过多地讨论关于这方面的数学知识。现在仅仅接受这样一个事实:我们需要确保每个向量的L2范数等于1。这里有一些代码,展示这是如何实现的。

import math

def l2_normalizer(vec):
  denom = np.sum([el**2 for el in vec])
  return [(el / math.sqrt(denom)) for el in vec]

doc_term_matrix_l2 = []
for vec in doc_term_matrix:
  doc_term_matrix_l2.append(l2_normalizer(vec))

print 'A regular old document term matrix: '
print np.matrix(doc_term_matrix)
print '\nA document term matrix with row-wise L2 norms of 1:'
print np.matrix(doc_term_matrix_l2)

# if you want to check this math, perform the following:
# from numpy import linalg as la
# la.norm(doc_term_matrix[0])
# la.norm(doc_term_matrix_l2[0])

格式化后的旧的文档词矩阵:

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

按行计算的L2范数为1的文档词矩阵:

[[ 0.57735027 0. 0.28867513 0. 0. 0.57735027
0. 0.28867513 0. 0.28867513 0.28867513]
[ 0.63245553 0. 0.31622777 0. 0.31622777 0.31622777
0.31622777 0. 0. 0.31622777 0.31622777]
[ 0. 0.40824829 0. 0.40824829 0.40824829 0. 0.
0. 0.40824829 0.40824829 0.40824829]]

还不错,没有太深究线性代数的知识,你就可以马上看到我们按比例缩小了各个向量,使它们的每一个元素都在0到1之间,并且不会丢失太多有价值的信息。你看到了,一个计数为1的词在一个向量中的值和其在另一个向量中的值不再相同。

为什么我们关心这种标准化吗?考虑这种情况,如果你想让一个文档看起来比它实际上和一个特定主题更相关,你可能会通过不断重复同一个词,来增加它包含到一个主题的可能性。坦率地说,在某种程度上,我们得到了一个在该词的信息价值上衰减的结果。所以我们需要按比例缩小那些在一篇文档中频繁出现的单词的值。

IDF频率加权

我们现在还没有得到想要的结果。就像一篇文档中的所有单词不具有相同的价值一样,也不是全部文档中的所有单词都有价值。我们尝试利用反文档词频(IDF)调整每一个单词权重。我们看看这包含了些什么:

def numDocsContaining(word, doclist):
  doccount = 0
  for doc in doclist:
    if freq(word, doc) > 0:
      doccount +=1
  return doccount 

def idf(word, doclist):
  n_samples = len(doclist)
  df = numDocsContaining(word, doclist)
  return np.log(n_samples / 1+df)

my_idf_vector = [idf(word, mydoclist) for word in vocabulary]

print 'Our vocabulary vector is [' + ', '.join(list(vocabulary)) + ']'
print 'The inverse document frequency vector is [' + ', '.join(format(freq, 'f') for freq in my_idf_vector) + ']'

我们的词向量为[me, basketball, Julie, baseball, likes, loves, Jane, Linda, He, than, more]

反文档词频向量为[1.609438, 1.386294, 1.609438, 1.386294, 1.609438, 1.609438, 1.386294, 1.386294, 1.386294, 1.791759, 1.791759]

现在,对于词汇中的每一个词,我们都有一个常规意义上的信息值,用于解释他们在整个语料库中的相对频率。回想一下,这个信息值是一个“逆”!即信息值越小的词,它在语料库中出现的越频繁。

我们快得到想要的结果了。为了得到TF-IDF加权词向量,你必须做一个简单的计算:tf * idf。

现在让我们退一步想想。回想下线性代数:如果你用一个AxB的向量乘以另一个AxB的向量,你将得到一个大小为AxA的向量,或者一个标量。我们不会那么做,因为我们想要的是一个具有相同维度(1 x词数量)的词向量,向量中的每个元素都已经被自己的idf权重加权了。我们如何在Python中实现这样的计算呢?

在这里我们可以编写完整的函数,但我们不那么做,我们将要对numpy做一个简介。

import numpy as np

def build_idf_matrix(idf_vector):
  idf_mat = np.zeros((len(idf_vector), len(idf_vector)))
  np.fill_diagonal(idf_mat, idf_vector)
  return idf_mat

my_idf_matrix = build_idf_matrix(my_idf_vector)

#print my_idf_matrix

太棒了!现在我们已经将IDF向量转化为BxB的矩阵了,矩阵的对角线就是IDF向量。这意味着我们现在可以用反文档词频矩阵乘以每一个词频向量了。接着,为了确保我们也考虑那些过于频繁地出现在文档中的词,我们将对每篇文档的向量进行标准化,使其L2范数等于1。

doc_term_matrix_tfidf = []

#performing tf-idf matrix multiplication
for tf_vector in doc_term_matrix:
  doc_term_matrix_tfidf.append(np.dot(tf_vector, my_idf_matrix))

#normalizing
doc_term_matrix_tfidf_l2 = []
for tf_vector in doc_term_matrix_tfidf:
  doc_term_matrix_tfidf_l2.append(l2_normalizer(tf_vector))

print vocabulary
print np.matrix(doc_term_matrix_tfidf_l2) # np.matrix() just to make it easier to look at

set(['me', 'basketball', 'Julie', 'baseball', 'likes', 'loves', 'Jane', 'Linda', 'He', 'than', 'more'])

[[ 0.57211257 0. 0.28605628 0. 0. 0.57211257
0. 0.24639547 0. 0.31846153 0.31846153]
[ 0.62558902 0. 0.31279451 0. 0.31279451 0.31279451
0.26942653 0. 0. 0.34822873 0.34822873]
[ 0. 0.36063612 0. 0.36063612 0.41868557 0. 0.
0. 0.36063612 0.46611542 0.46611542]]

太棒了!你刚看到了一个展示如何繁琐地建立一个TF-IDF加权的文档词矩阵的例子。

最好的部分来了:你甚至不需要手动计算上述变量,使用scikit-learn即可。

记住,Python中的一切都是一个对象,对象本身占用内存,同时对象执行操作占用时间。使用scikit-learn包,以确保你不必担心前面所有步骤的效率问题。

注意:你从TfidfVectorizer/TfidfTransformer得到的值将和我们手动计算的值不同。这是因为scikit-learn使用一个Tfidf的改进版本处理除零的错误。这里有一个更深入的讨论。

from sklearn.feature_extraction.text import CountVectorizer

count_vectorizer = CountVectorizer(min_df=1)
term_freq_matrix = count_vectorizer.fit_transform(mydoclist)
print "Vocabulary:", count_vectorizer.vocabulary_

from sklearn.feature_extraction.text import TfidfTransformer

tfidf = TfidfTransformer(norm="l2")
tfidf.fit(term_freq_matrix)

tf_idf_matrix = tfidf.transform(term_freq_matrix)
print tf_idf_matrix.todense()

Vocabulary: {u'me': 8, u'basketball': 1, u'julie': 4, u'baseball': 0, u'likes': 5, u'loves': 7, u'jane': 3, u'linda': 6, u'more': 9, u'than': 10, u'he': 2}
[[ 0. 0. 0. 0. 0.28945906 0.
0.38060387 0.57891811 0.57891811 0.22479078 0.22479078]
[ 0. 0. 0. 0.41715759 0.3172591 0.3172591
0. 0.3172591 0.6345182 0.24637999 0.24637999]
[ 0.48359121 0.48359121 0.48359121 0. 0. 0.36778358
0. 0. 0. 0.28561676 0.28561676]]

实际上,你可以用一个函数完成所有的步骤:TfidfVectorizer

from sklearn.feature_extraction.text import TfidfVectorizer

tfidf_vectorizer = TfidfVectorizer(min_df = 1)
tfidf_matrix = tfidf_vectorizer.fit_transform(mydoclist)

print tfidf_matrix.todense()
[[ 0. 0. 0. 0. 0.28945906 0.
0.38060387 0.57891811 0.57891811 0.22479078 0.22479078]
[ 0. 0. 0. 0.41715759 0.3172591 0.3172591
0. 0.3172591 0.6345182 0.24637999 0.24637999]
[ 0.48359121 0.48359121 0.48359121 0. 0. 0.36778358
0. 0. 0. 0.28561676 0.28561676]]

并且我们可以利用这个词汇空间处理新的观测文档,就像这样:

new_docs = ['He watches basketball and baseball', 'Julie likes to play basketball', 'Jane loves to play baseball']
new_term_freq_matrix = tfidf_vectorizer.transform(new_docs)
print tfidf_vectorizer.vocabulary_
print new_term_freq_matrix.todense()
{u'me': 8, u'basketball': 1, u'julie': 4, u'baseball': 0, u'likes': 5, u'loves': 7, u'jane': 3, u'linda': 6, u'more': 9, u'than': 10, u'he': 2}
[[ 0.57735027 0.57735027 0.57735027 0. 0. 0. 0.
0. 0. 0. 0. ]
[ 0. 0.68091856 0. 0. 0.51785612 0.51785612
0. 0. 0. 0. 0. ]
[ 0.62276601 0. 0. 0.62276601 0. 0. 0.
0.4736296 0. 0. 0. ]]

请注意,在new_term_freq_matrix中并没有“watches”这样的单词。这是因为我们用于训练的文档是mydoclist中的文档,这个词并不会出现在那个语料库的词汇中。换句话说,它在我们的词汇词典之外。

回到Amazon评论文本

练习2

现在是时候尝试使用你学过的东西了。利用TfidfVectorizer,你可以在Amazon评论文本的字符串列表上尝试建立一个TF-IDF加权文档词矩。

import os
import csv

#os.chdir('/Users/rweiss/Dropbox/presentations/IRiSS2013/text1/fileformats/')

with open('amazon/sociology_2010.csv', 'rb') as csvfile:
  amazon_reader = csv.DictReader(csvfile, delimiter=',')
  amazon_reviews = [row['review_text'] for row in amazon_reader]

  #your code here!!!
(0)

相关推荐

  • 理解生产者消费者模型及在Python编程中的运用实例

    什么是生产者消费者模型 在 工作中,大家可能会碰到这样一种情况:某个模块负责产生数据,这些数据由另一个模块来负责处理(此处的模块是广义的,可以是类.函数.线程.进程等).产 生数据的模块,就形象地称为生产者:而处理数据的模块,就称为消费者.在生产者与消费者之间在加个缓冲区,我们形象的称之为仓库,生产者负责往仓库了进商 品,而消费者负责从仓库里拿商品,这就构成了生产者消费者模型.结构图如下: 生产者消费者模型的优点: 1.解耦 假设生产者和消费者分别是两个类.如果让生产者直接调用消费者的某个方法,

  • Python探索之pLSA实现代码

    pLSA(probabilistic Latent Semantic Analysis),概率潜在语义分析模型,是1999年Hoffman提出的一个被称为第一个能解决一词多义问题的模型,通过在文档与单词之间建立一层主题(Topic),将文档与单词的直接关联转化为文档与主题的关联以及主题与单词的关联.这里采用EM算法进行估计,可能存在差错,望积极批评指正. # -*- coding: utf-8 -*- import math import random import jieba import c

  • python基于隐马尔可夫模型实现中文拼音输入

    在网上看到一篇关于隐马尔科夫模型的介绍,觉得简直不能再神奇,又在网上找到大神的一篇关于如何用隐马尔可夫模型实现中文拼音输入的博客,无奈大神没给可以运行的代码,只能纯手动网上找到了结巴分词的词库,根据此训练得出隐马尔科夫模型,用维特比算法实现了一个简单的拼音输入法.githuh地址:https://github.com/LiuRoy/Pinyin_Demo 原理简介隐马尔科夫模型 抄一段网上的定义: 隐马尔可夫模型 (Hidden Markov Model) 是一种统计模型,用来描述一个含有隐含未

  • 基于python yield机制的异步操作同步化编程模型

    本文总结下如何在编写python代码时对异步操作进行同步化模拟,从而提高代码的可读性和可扩展性. 游戏引擎一般都采用分布式框架,通过一定的策略来均衡服务器集群的资源负载,从而保证服务器运算的高并发性和CPU高利用率,最终提高游戏的性能和负载.由于引擎的逻辑层调用是非抢占式的,服务器之间都是通过异步调用来进行通讯,导致游戏逻辑无法同步执行,所以在代码层不得不人为地添加很多回调函数,使一个原本完整的功能碎片化地分布在各个回调函数中. 异步逻辑 以游戏中的副本评分逻辑为例,在副本结束时副本管理进程需要

  • 用Python的SimPy库简化复杂的编程模型的介绍

    在我遇到 SimPy 包的其中一位创始人 Klaus Miller 时,从他那里知道了这个包.Miller 博士阅读过几篇提出使用 Python 2.2+ 生成器实现半协同例程和"轻便"线程的技术的 可爱的 Python专栏文章.特别是(使我很高兴的是),他发现在用 Python 实现 Simula-67 样式模拟时,这些技术很有用. 结果表明 Tony Vignaux 和 Chang Chui 以前曾创建了另一个 Python 库,它在概念上更接近于 Simscript,而且该库使用

  • 用Python给文本创立向量空间模型的教程

    我们需要开始思考如何将文本集合转化为可量化的东西.最简单的方法是考虑词频. 我将尽量尝试不使用NLTK和Scikits-Learn包.我们首先使用Python讲解一些基本概念. 基本词频 首先,我们回顾一下如何得到每篇文档中的词的个数:一个词频向量. #examples taken from here: http://stackoverflow.com/a/1750187 mydoclist = ['Julie loves me more than Linda loves me', 'Jane

  • Python+Opencv文本检测的实现

    目录 EAST 深度学习文本检测器 项目结构 实施说明 使用 OpenCV 实现我们的文本检测器 OpenCV 文本检测结果 视频文字检测结果 在本教程中,您将学习如何使用 OpenCV 使用 EAST 文本检测器检测图像中的文本. EAST 文本检测器要求我们在我们的系统上运行 OpenCV 3.4.2 或 OpenCV 4 . 论文原文 代码地址 原文 在今天教程的第一部分中,我将讨论为什么在自然场景图像中检测文本会如此具有挑战性. 从那里我将简要讨论 EAST 文本检测器,我们为什么使用它

  • Python实现文本特征提取的方法详解

    目录 1.字典文本特征提取 DictVectorizer() 1.1 one-hot编码 1.2 字典数据转sparse矩阵 2.英文文本特征提取 3.中文文本特征提取 4. TF-IDF 文本特征提取 TfidfVectorizer() 1.字典文本特征提取 DictVectorizer() 1.1 one-hot编码 创建一个字典,观察如下数据形式的变化: import pandas as pd from sklearn.feature_extraction import DictVecto

  • 浅谈Python基础之I/O模型

    一.I/O模型 IO在计算机中指Input/Output,也就是输入和输出.由于程序和运行时数据是在内存中驻留,由CPU这个超快的计算核心来执行,涉及到数据交换的地方,通常是磁盘.网络等,就需要IO接口. 同步(synchronous) IO和异步(asynchronous) IO,阻塞(blocking) IO和非阻塞(non-blocking)IO分别是什么,到底有什么区别? 这个问题其实不同的人给出的答案都可能不同,比如wiki,就认为asynchronous IO和non-blockin

  • Python做文本按行去重的实现方法

    文本: 每行在promotion后面包含一些数字,如果这些数字是相同的,则认为是相同的行,对于相同的行,只保留一行. 思路: 根据字典和字符串切割. 建立一个空字典. 读入文本,并对每行切割前半部分,在读入文本的过程中循环在这个字典中查找,如果没找到,则写入该行到字典.否则,则表示该行已经被写入过字典了(即出现重复的行了),不再写入字典,这就实现了对于重复的行只保留一行的目的. 文本如下: /promotion/232 utm_source /promotion/237 LandingPage/

  • python将文本转换成图片输出的方法

    本文实例讲述了python将文本转换成图片输出的方法.分享给大家供大家参考.具体实现方法如下: #-*- coding:utf-8 -*- from PIL import Image,ImageFont,ImageDraw text = u'欢迎访问我们,http://www.jb51.net' font = ImageFont.truetype("msyh.ttf",18) lines = [] line ='' for word in text.split(): print wor

  • python简单文本处理的方法

    本文实例讲述了python简单文本处理的方法.分享给大家供大家参考.具体如下: 由于有多线程的影响,c++项目打印出来的时间顺序不一致,导致不太好在excel中统计,故使用python写了段脚本来解决之.涉及到如下方面 1. txt文本的读取,utf8的处理 2. 字符串的基本操作 3. dict的基本操作 4. list(数组)的基本操作 #!/usr/bin/python #print "Hello World" str_seperator = "============

  • python统计文本字符串里单词出现频率的方法

    本文实例讲述了python统计文本字符串里单词出现频率的方法.分享给大家供大家参考.具体实现方法如下: # word frequency in a text # tested with Python24 vegaseat 25aug2005 # Chinese wisdom ... str1 = """Man who run in front of car, get tired. Man who run behind car, get exhausted."&quo

  • Python判断文本中消息重复次数的方法

    本文实例讲述了Python判断文本中消息重复次数的方法.分享给大家供大家参考,具体如下: #coding:gbk ''' Created on 2012-2-3 从文件中读取文本,并判断文本中形如"message0"."message123"这样的消息有多少条是重复的 @author: Administrator ''' import re if __name__ == '__main__': pattern = u"(message((\d)+))&qu

  • Python处理文本换行符实例代码

    本文研究的主要是Python处理文本换行符的相关内容,具体如下. 源文件每行后面都有回车,所以用下面输出时,中间会多了一行 try: with open("F:\\hjt.txt" ) as f : for line in f: print(line) except FileNotFoundError: print("读取文件出错") 有两种方法处理: 1.print后面带 end='',表示不换行 try: with open("F:\\hjt.txt&

随机推荐