FeatureHasher 和 DictVectorizer 比较#
在本例中，我们将说明文本向量化，它是将非数值输入数据（如字典或文本文档）表示为实数向量。
我们首先通过使用两种方法对使用自定义 Python 函数预处理（标记化）的文本文档进行向量化来比较 FeatureHasher 和 DictVectorizer。
稍后，我们将介绍和分析文本特定的向量化器 HashingVectorizer、CountVectorizer 和 TfidfVectorizer，它们在一个类中处理标记化和特征矩阵的组装。
本例的目的是演示文本向量化 API 的用法，并比较它们的处理时间。有关文本文档的实际学习，请参阅示例脚本 使用稀疏特征对文本文档进行分类 和 使用 k 均值对文本文档进行聚类。
# Author: Lars Buitinck
# Olivier Grisel <[email protected]>
# Arturo Amor <[email protected]>
# License: BSD 3 clause
加载数据#
我们从 20 个新闻组文本数据集 加载数据，该数据集包含大约 18000 个新闻组帖子，涵盖 20 个主题，分为两个子集：一个用于训练，一个用于测试。为了简单起见并降低计算成本，我们选择 7 个主题的子集，并且仅使用训练集。
from sklearn.datasets import fetch_20newsgroups
categories = [
"alt.atheism",
"comp.graphics",
"comp.sys.ibm.pc.hardware",
"misc.forsale",
"rec.autos",
"sci.space",
"talk.religion.misc",
]
print("Loading 20 newsgroups training data")
raw_data, _ = fetch_20newsgroups(subset="train", categories=categories, return_X_y=True)
data_size_mb = sum(len(s.encode("utf-8")) for s in raw_data) / 1e6
print(f"{len(raw_data)} documents - {data_size_mb:.3f}MB")
Loading 20 newsgroups training data
3803 documents - 6.245MB
定义预处理函数#
一个词元可以是一个词、一个词的一部分，或者字符串中空格或符号之间的任何内容。在这里，我们定义一个函数，使用一个简单的正则表达式 (regex) 来提取词元，该表达式匹配 Unicode 词字符。这包括大多数可以作为任何语言中词的一部分的字符，以及数字和下划线。
import re
def tokenize(doc):
"""Extract tokens from doc.
This uses a simple regex that matches word characters to break strings
into tokens. For a more principled approach, see CountVectorizer or
TfidfVectorizer.
"""
return (tok.lower() for tok in re.findall(r"\w+", doc))
list(tokenize("This is a simple example, isn't it?"))
['this', 'is', 'a', 'simple', 'example', 'isn', 't', 'it']
我们定义了另一个函数，用于计算给定文档中每个词元的出现次数（频率）。它返回一个频率字典，供向量化器使用。
from collections import defaultdict
def token_freqs(doc):
"""Extract a dict mapping tokens from doc to their occurrences."""
freq = defaultdict(int)
for tok in tokenize(doc):
freq[tok] += 1
return freq
token_freqs("That is one example, but this is another one")
defaultdict(<class 'int'>, {'that': 1, 'is': 2, 'one': 2, 'example': 1, 'but': 1, 'this': 1, 'another': 1})
特别要注意，重复的词元 "is" 例如被计算了两次。
将文本文档分解成词元，可能丢失句子中词之间的顺序信息，通常被称为 词袋模型。
DictVectorizer#
首先，我们对 DictVectorizer 进行基准测试，然后将其与 FeatureHasher 进行比较，因为它们都接收字典作为输入。
from time import time
from sklearn.feature_extraction import DictVectorizer
dict_count_vectorizers = defaultdict(list)
t0 = time()
vectorizer = DictVectorizer()
vectorizer.fit_transform(token_freqs(d) for d in raw_data)
duration = time() - t0
dict_count_vectorizers["vectorizer"].append(
vectorizer.__class__.__name__ + "\non freq dicts"
)
dict_count_vectorizers["speed"].append(data_size_mb / duration)
print(f"done in {duration:.3f} s at {data_size_mb / duration:.1f} MB/s")
print(f"Found {len(vectorizer.get_feature_names_out())} unique terms")
done in 1.134 s at 5.5 MB/s
Found 47928 unique terms
从文本词元到列索引的实际映射显式地存储在 .vocabulary_ 属性中，该属性是一个可能非常大的 Python 字典。
type(vectorizer.vocabulary_)
len(vectorizer.vocabulary_)
47928
vectorizer.vocabulary_["example"]
19145
FeatureHasher#
字典占用大量的存储空间，并且随着训练集的增长而增大。特征哈希不是随着字典一起增长向量，而是通过对特征（例如，词元）应用哈希函数 h 来构建一个预定义长度的向量，然后直接使用哈希值作为特征索引，并在这些索引处更新结果向量。当特征空间不够大时，哈希函数往往会将不同的值映射到相同的哈希码（哈希冲突）。因此，无法确定哪个对象生成了任何特定的哈希码。
由于上述原因，无法从特征矩阵中恢复原始词元，估计原始字典中唯一词元数量的最佳方法是计算编码特征矩阵中活动列的数量。为此，我们定义了以下函数。
import numpy as np
def n_nonzero_columns(X):
"""Number of columns with at least one non-zero value in a CSR matrix.
This is useful to count the number of features columns that are effectively
active when using the FeatureHasher.
"""
return len(np.unique(X.nonzero()[1]))
FeatureHasher 的默认特征数量为 2**20。在这里，我们设置 n_features = 2**18 来演示哈希冲突。
FeatureHasher 用于频率字典
from sklearn.feature_extraction import FeatureHasher
t0 = time()
hasher = FeatureHasher(n_features=2**18)
X = hasher.transform(token_freqs(d) for d in raw_data)
duration = time() - t0
dict_count_vectorizers["vectorizer"].append(
hasher.__class__.__name__ + "\non freq dicts"
)
dict_count_vectorizers["speed"].append(data_size_mb / duration)
print(f"done in {duration:.3f} s at {data_size_mb / duration:.1f} MB/s")
print(f"Found {n_nonzero_columns(X)} unique tokens")
done in 0.599 s at 10.4 MB/s
Found 43873 unique tokens
使用 FeatureHasher 时，唯一词元的数量低于使用 DictVectorizer 获得的数量。这是由于哈希冲突。
可以通过增加特征空间来减少冲突数量。请注意，当设置大量特征时，向量化的速度不会发生明显变化，尽管它会导致更大的系数维度，然后需要更多内存来存储它们，即使其中大部分是未激活的。
t0 = time()
hasher = FeatureHasher(n_features=2**22)
X = hasher.transform(token_freqs(d) for d in raw_data)
duration = time() - t0
print(f"done in {duration:.3f} s at {data_size_mb / duration:.1f} MB/s")
print(f"Found {n_nonzero_columns(X)} unique tokens")
done in 0.580 s at 10.8 MB/s
Found 47668 unique tokens
我们确认，唯一词元的数量越来越接近使用 DictVectorizer 找到的唯一词元数量。
FeatureHasher 用于原始词元
或者，可以在 FeatureHasher 中设置 input_type="string" 来直接向量化来自自定义 tokenize 函数的字符串输出。这等效于传递一个字典，其中每个特征名称的隐含频率为 1。
t0 = time()
hasher = FeatureHasher(n_features=2**18, input_type="string")
X = hasher.transform(tokenize(d) for d in raw_data)
duration = time() - t0
dict_count_vectorizers["vectorizer"].append(
hasher.__class__.__name__ + "\non raw tokens"
)
dict_count_vectorizers["speed"].append(data_size_mb / duration)
print(f"done in {duration:.3f} s at {data_size_mb / duration:.1f} MB/s")
print(f"Found {n_nonzero_columns(X)} unique tokens")
done in 0.573 s at 10.9 MB/s
Found 43873 unique tokens
现在，我们绘制上述方法用于向量化的速度。
import matplotlib.pyplot as plt
fig, ax = plt.subplots(figsize=(12, 6))
y_pos = np.arange(len(dict_count_vectorizers["vectorizer"]))
ax.barh(y_pos, dict_count_vectorizers["speed"], align="center")
ax.set_yticks(y_pos)
ax.set_yticklabels(dict_count_vectorizers["vectorizer"])
ax.invert_yaxis()
_ = ax.set_xlabel("speed (MB/s)")
在这两种情况下， FeatureHasher 的速度大约是 DictVectorizer 的两倍。这在处理大量数据时非常方便，缺点是失去了转换的可逆性，这反过来使得模型的解释变得更加复杂。
FeatureHeasher 与 input_type="string" 的速度略快于在频率字典上工作的变体，因为它不会计算重复的词元：每个词元隐式地计算一次，即使它被重复了。根据下游机器学习任务，这可能是一个限制或不是。
与专用文本向量化器的比较#
CountVectorizer 接受原始数据，因为它在内部实现了词元化和出现次数统计。它类似于与自定义函数 token_freqs 一起使用时的 DictVectorizer，如上一节所述。区别在于 CountVectorizer 更加灵活。特别是，它通过 token_pattern 参数接受各种正则表达式模式。
from sklearn.feature_extraction.text import CountVectorizer
t0 = time()
vectorizer = CountVectorizer()
vectorizer.fit_transform(raw_data)
duration = time() - t0
dict_count_vectorizers["vectorizer"].append(vectorizer.__class__.__name__)
dict_count_vectorizers["speed"].append(data_size_mb / duration)
print(f"done in {duration:.3f} s at {data_size_mb / duration:.1f} MB/s")
print(f"Found {len(vectorizer.get_feature_names_out())} unique terms")
done in 0.744 s at 8.4 MB/s
Found 47885 unique terms
我们看到，使用 CountVectorizer 实现的速度大约是使用 DictVectorizer 以及我们为映射词元定义的简单函数的两倍。原因是 CountVectorizer 通过重用为整个训练集编译的正则表达式来进行优化，而不是像我们简单的词元化函数那样为每个文档创建一个正则表达式。
现在，我们对 HashingVectorizer 进行类似的实验，它等效于将 FeatureHasher 类实现的“哈希技巧”与 CountVectorizer 的文本预处理和词元化相结合。
from sklearn.feature_extraction.text import HashingVectorizer
t0 = time()
vectorizer = HashingVectorizer(n_features=2**18)
vectorizer.fit_transform(raw_data)
duration = time() - t0
dict_count_vectorizers["vectorizer"].append(vectorizer.__class__.__name__)
dict_count_vectorizers["speed"].append(data_size_mb / duration)
print(f"done in {duration:.3f} s at {data_size_mb / duration:.1f} MB/s")
done in 0.558 s at 11.2 MB/s
我们可以观察到，这是迄今为止最快的文本词元化策略，假设下游机器学习任务可以容忍一些冲突。
TfidfVectorizer#
在一个大型文本语料库中，一些词语出现的频率较高（例如，英语中的“the”、“a”、“is”），并且不包含有关文档实际内容的有意义信息。如果我们将词语计数数据直接提供给分类器，这些非常常见的词语会掩盖更罕见但更有信息的词语的频率。为了将计数特征重新加权成适合分类器使用的浮点数，通常使用 TfidfTransformer 实现的 tf-idf 变换。TF 代表“词语频率”，而“tf-idf”代表词语频率乘以逆文档频率。
现在，我们对 TfidfVectorizer 进行基准测试，它等效于将 CountVectorizer 的词元化和出现次数统计与来自 TfidfTransformer 的归一化和加权相结合。
from sklearn.feature_extraction.text import TfidfVectorizer
t0 = time()
vectorizer = TfidfVectorizer()
vectorizer.fit_transform(raw_data)
duration = time() - t0
dict_count_vectorizers["vectorizer"].append(vectorizer.__class__.__name__)
dict_count_vectorizers["speed"].append(data_size_mb / duration)
print(f"done in {duration:.3f} s at {data_size_mb / duration:.1f} MB/s")
print(f"Found {len(vectorizer.get_feature_names_out())} unique terms")
done in 0.759 s at 8.2 MB/s
Found 47885 unique terms
总结#
让我们通过在一个图中总结所有记录的处理速度来结束这个笔记本。
fig, ax = plt.subplots(figsize=(12, 6))
y_pos = np.arange(len(dict_count_vectorizers["vectorizer"]))
ax.barh(y_pos, dict_count_vectorizers["speed"], align="center")
ax.set_yticks(y_pos)
ax.set_yticklabels(dict_count_vectorizers["vectorizer"])
ax.invert_yaxis()
_ = ax.set_xlabel("speed (MB/s)")
从图中可以看出，TfidfVectorizer 比 CountVectorizer 稍微慢一些，因为 TfidfTransformer 引入了额外的操作。
另外，通过设置特征数量 n_features = 2**18，HashingVectorizer 的性能优于 CountVectorizer，但由于哈希冲突，转换不可逆。
我们强调，对于手动标记的文档，CountVectorizer 和 HashingVectorizer 的性能优于等效的 DictVectorizer 和 FeatureHasher，因为前者向量化器内部的标记步骤会编译一个正则表达式，然后将其重复用于所有文档。
脚本总运行时间：（0 分钟 5.461 秒）
相关示例
