8.2. 特征提取#

sklearn.feature_extraction 模块可用于将文本和图像等格式的数据集提取为机器学习算法支持的特征格式。

注意

特征提取与 特征选择 有很大不同：前者是将文本或图像等任意数据转换为机器学习可用的数值特征；而后者是一种应用于这些特征的机器学习技术。

8.2.1. 从字典（dicts）中加载特征#

DictVectorizer 类可用于将表现为标准 Python dict 对象列表的特征数组转换为 scikit-learn 估计器使用的 NumPy/SciPy 表示形式。

虽然处理速度不是特别快，但 Python 的 dict 具有使用方便、稀疏（无需存储不存在的特征）以及除值之外还可以存储特征名称的优点。

DictVectorizer 实现了针对分类（即定性、离散）特征的“独热”（one-hot）编码。分类特征是“属性-值”对，其中值被限制在一系列无序的离散可能性中（例如主题标识符、对象类型、标签、名称等）。

在下文中，“城市”是一个分类属性，而“温度”是一个传统的数值特征。

>>> measurements = [
...     {'city': 'Dubai', 'temperature': 33.},
...     {'city': 'London', 'temperature': 12.},
...     {'city': 'San Francisco', 'temperature': 18.},
... ]

>>> from sklearn.feature_extraction import DictVectorizer
>>> vec = DictVectorizer()

>>> vec.fit_transform(measurements).toarray()
array([[ 1.,  0.,  0., 33.],
       [ 0.,  1.,  0., 12.],
       [ 0.,  0.,  1., 18.]])

>>> vec.get_feature_names_out()
array(['city=Dubai', 'city=London', 'city=San Francisco', 'temperature'], ...)

DictVectorizer 接受一个特征的多个字符串值，例如电影的多个类别。

假设某个数据库使用某些类别（非强制性）及其发布年份对每部电影进行分类。

>>> movie_entry = [{'category': ['thriller', 'drama'], 'year': 2003},
...                {'category': ['animation', 'family'], 'year': 2011},
...                {'year': 1974}]
>>> vec.fit_transform(movie_entry).toarray()
array([[0.000e+00, 1.000e+00, 0.000e+00, 1.000e+00, 2.003e+03],
       [1.000e+00, 0.000e+00, 1.000e+00, 0.000e+00, 2.011e+03],
       [0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 1.974e+03]])
>>> vec.get_feature_names_out()
array(['category=animation', 'category=drama', 'category=family',
       'category=thriller', 'year'], ...)
>>> vec.transform({'category': ['thriller'],
...                'unseen_feature': '3'}).toarray()
array([[0., 0., 0., 1., 0.]])

DictVectorizer 对于训练自然语言处理模型中的序列分类器也是一种有用的表示转换，这些模型通常通过提取感兴趣词周围的特征窗口来工作。

例如，假设我们有一个首先提取词性（PoS）标签的算法，我们希望将其用作训练序列分类器（例如分块器）的补充标签。以下字典可以是句子“The cat sat on the mat.”中单词“sat”周围提取的特征窗口。

>>> pos_window = [
...     {
...         'word-2': 'the',
...         'pos-2': 'DT',
...         'word-1': 'cat',
...         'pos-1': 'NN',
...         'word+1': 'on',
...         'pos+1': 'PP',
...     },
...     # in a real application one would extract many such dictionaries
... ]

此描述可以向量化为稀疏二维矩阵，适合馈送到分类器中（或许在通过 TfidfTransformer 进行归一化处理之后）。

>>> vec = DictVectorizer()
>>> pos_vectorized = vec.fit_transform(pos_window)
>>> pos_vectorized
<Compressed Sparse...dtype 'float64'
  with 6 stored elements and shape (1, 6)>
>>> pos_vectorized.toarray()
array([[1., 1., 1., 1., 1., 1.]])
>>> vec.get_feature_names_out()
array(['pos+1=PP', 'pos-1=NN', 'pos-2=DT', 'word+1=on', 'word-1=cat',
       'word-2=the'], ...)

可以想象，如果从文档语料库的每个单词周围提取这样的上下文，生成的矩阵将会非常宽（有很多独热特征），并且大部分时间它们的值为零。为了使生成的结构能够装入内存，DictVectorizer 类默认使用 scipy.sparse 矩阵而不是 numpy.ndarray。

8.2.2. 特征哈希（Feature hashing）#

FeatureHasher 类是一个高速、低内存的向量化器，它使用了被称为 特征哈希 或“哈希技巧”的技术。与向量化器构建所遇到特征的哈希表不同，FeatureHasher 的实例通过对特征应用哈希函数来直接确定它们在样本矩阵中的列索引。其结果是提高了速度并减少了内存使用，但代价是可检查性降低；哈希器不记录输入特征的样子，也没有 inverse_transform 方法。

由于哈希函数可能会导致（无关）特征之间发生冲突，因此使用带符号的哈希函数，并且哈希值的符号决定了特征在输出矩阵中存储的值的符号。通过这种方式，冲突往往会相互抵消而不是累积误差，并且任何输出特征值的期望平均值为零。此机制默认启用 alternate_sign=True，对于较小的哈希表大小（n_features < 10000）特别有用。对于较大的哈希表大小，可以将其禁用，以允许将输出传递给诸如 MultinomialNB 或 chi2 特征选择器等需要非负输入的估计器。

FeatureHasher 接受映射（如 Python 的 dict 及其 collections 模块中的变体）、(feature, value) 对或字符串，具体取决于构造函数参数 input_type。映射被视为 (feature, value) 对的列表，而单个字符串的默认值为 1，因此 ['feat1', 'feat2', 'feat3'] 被解释为 [('feat1', 1), ('feat2', 1), ('feat3', 1)]。如果单个特征在样本中出现多次，关联的值将被求和（因此 ('feat', 2) 和 ('feat', 3.5) 变为 ('feat', 5.5)）。FeatureHasher 的输出始终是 CSR 格式的 scipy.sparse 矩阵。

特征哈希可用于文档分类，但与 CountVectorizer 不同，FeatureHasher 不进行分词或除 Unicode 到 UTF-8 编码之外的任何其他预处理；请参阅下文 使用哈希技巧对大型文本语料库进行向量化 以获取组合的标记器/哈希器。

例如，考虑一个需要从 (token, part_of_speech) 对中提取特征的单词级自然语言处理任务。可以使用 Python 生成器函数来提取特征。

def token_features(token, part_of_speech):
    if token.isdigit():
        yield "numeric"
    else:
        yield "token={}".format(token.lower())
        yield "token,pos={},{}".format(token, part_of_speech)
    if token[0].isupper():
        yield "uppercase_initial"
    if token.isupper():
        yield "all_uppercase"
    yield "pos={}".format(part_of_speech)

然后，可以使用以下方式构建要馈送到 FeatureHasher.transform 的 raw_X：

raw_X = (token_features(tok, pos_tagger(tok)) for tok in corpus)

并将其馈送到哈希器：

hasher = FeatureHasher(input_type='string')
X = hasher.transform(raw_X)

以获得 scipy.sparse 矩阵 X。

注意使用了生成器推导式，这在特征提取中引入了惰性求值：标记仅在哈希器按需请求时才被处理。

实现细节#

FeatureHasher 使用 MurmurHash3 的有符号 32 位变体。因此（以及由于 scipy.sparse 中的限制），目前支持的最大特征数为 \(2^{31} - 1\)。

Weinberger 等人最初提出的哈希技巧使用了两个独立的哈希函数 \(h\) 和 \(\xi\) 分别确定特征的列索引和符号。目前的实现假设 MurmurHash3 的符号位与其其他位无关。

由于使用简单的模运算将哈希函数转换为列索引，建议使用 2 的幂作为 n_features 参数；否则特征将无法均匀映射到各列。

References

References

8.2.3. 文本特征提取#

8.2.3.1. 词袋（Bag of Words）表示#

文本分析是机器学习算法的一个主要应用领域。然而，作为符号序列的原始数据不能直接馈送到算法本身，因为大多数算法需要固定大小的数值特征向量，而不是长度可变的原始文本文档。

为了解决这个问题，scikit-learn 提供了从文本内容中提取数值特征的最常见方法的工具，即：

  • 分词：对字符串进行分词，并为每个可能的词（token）赋予一个整数 ID，例如通过使用空格和标点符号作为分隔符。

  • 计数：计算每个文档中每个词出现的次数。

  • 归一化：对在大多数样本/文档中出现的词进行降权处理。

在这种方案中，特征和样本定义如下：

  • 每个 单独的词出现频率（无论是否归一化）都被视为一个 特征。

  • 给定 文档 的所有词频向量被视为一个多变量 样本。

因此，文档语料库可以用一个矩阵来表示，其中每一行代表一个文档，每一列代表语料库中出现的每个词（例如单词）。

我们将把文本集合转换为数值特征向量的通用过程称为 向量化。这种特定的策略（分词、计数和归一化）被称为 词袋（Bag of Words） 或“n-gram 袋”表示。文档由单词出现次数来描述，完全忽略了单词在文档中的相对位置信息。

8.2.3.2. 稀疏性#

由于大多数文档通常只使用语料库中单词的一小部分，结果矩阵中会有许多零值特征（通常超过 99%）。

例如，10,000 个短文本文档（如电子邮件）的集合将使用总量约 100,000 个唯一单词的词汇表，而每个文档单独使用 100 到 1000 个唯一单词。

为了能够将此类矩阵存储在内存中并加快矩阵/向量的代数运算，实现通常使用稀疏表示，例如 scipy.sparse 包中提供的实现。

8.2.3.3. 常用向量化器用法#

CountVectorizer 在一个类中实现了分词和计数：

>>> from sklearn.feature_extraction.text import CountVectorizer

该模型有许多参数，但默认值非常合理（详情请参阅 参考文档）。

>>> vectorizer = CountVectorizer()
>>> vectorizer
CountVectorizer()

让我们使用它来对极简文本语料库进行分词并计数：

>>> corpus = [
...     'This is the first document.',
...     'This is the second second document.',
...     'And the third one.',
...     'Is this the first document?',
... ]
>>> X = vectorizer.fit_transform(corpus)
>>> X
<Compressed Sparse...dtype 'int64'
  with 19 stored elements and shape (4, 9)>

默认配置通过提取至少 2 个字母的单词来对字符串进行分词。执行此步骤的特定函数可以显式请求：

>>> analyze = vectorizer.build_analyzer()
>>> analyze("This is a text document to analyze.") == (
...     ['this', 'is', 'text', 'document', 'to', 'analyze'])
True

拟合（fit）期间由分析器找到的每个词都被分配了一个唯一的整数索引，对应于结果矩阵中的一列。这种对列的解释可以通过以下方式获取：

>>> vectorizer.get_feature_names_out()
array(['and', 'document', 'first', 'is', 'one', 'second', 'the',
       'third', 'this'], ...)

>>> X.toarray()
array([[0, 1, 1, 1, 0, 0, 1, 0, 1],
       [0, 1, 0, 1, 0, 2, 1, 0, 1],
       [1, 0, 0, 0, 1, 0, 1, 1, 0],
       [0, 1, 1, 1, 0, 0, 1, 0, 1]]...)

从特征名称到列索引的逆映射存储在向量化器的 vocabulary_ 属性中：

>>> vectorizer.vocabulary_.get('document')
1

因此，在训练语料库中未见过的单词将在未来对 transform 方法的调用中被完全忽略。

>>> vectorizer.transform(['Something completely new.']).toarray()
array([[0, 0, 0, 0, 0, 0, 0, 0, 0]]...)

注意，在之前的语料库中，第一个和最后一个文档拥有完全相同的单词，因此被编码为相等的向量。特别是，我们丢失了最后一个文档是疑问句形式的信息。为了保留一些局部顺序信息，除了 1-gram（单个单词）之外，我们还可以提取单词的 2-gram：

>>> bigram_vectorizer = CountVectorizer(ngram_range=(1, 2),
...                                     token_pattern=r'\b\w+\b', min_df=1)
>>> analyze = bigram_vectorizer.build_analyzer()
>>> analyze('Bi-grams are cool!') == (
...     ['bi', 'grams', 'are', 'cool', 'bi grams', 'grams are', 'are cool'])
True

该向量化器提取的词汇表因此大得多，现在可以解决局部定位模式中编码的歧义。

>>> X_2 = bigram_vectorizer.fit_transform(corpus).toarray()
>>> X_2
array([[0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0],
       [0, 0, 1, 0, 0, 1, 1, 0, 0, 2, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0],
       [1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0],
       [0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1]]...)

特别是疑问形式“Is this”仅出现在最后一个文档中。

>>> feature_index = bigram_vectorizer.vocabulary_.get('is this')
>>> X_2[:, feature_index]
array([0, 0, 0, 1]...)

8.2.3.4. 使用停用词#

停用词是像“and”、“the”、“him”这样被认为在表示文本内容方面缺乏信息量的单词，可以将其删除以避免它们被误认为是预测的信息。然而，有时类似的词对于预测很有用，例如在分类写作风格或个性时。

我们提供的“english”停用词列表存在一些已知问题。它并不旨在成为通用的“一刀切”解决方案，因为某些任务可能需要更自定义的解决方案。有关更多详细信息，请参阅 [NQY18]。

请在选择停用词列表时小心。流行的停用词列表可能包含对于某些任务非常有信息量的词，例如 computer。

您还应确保停用词列表与向量化器中使用的预处理和分词方式相同。单词 we’ve 被 CountVectorizer 的默认分词器拆分为 we 和 ve，因此如果 we’ve 在 stop_words 中，但 ve 不在，那么 ve 将在转换后的文本中被保留。我们的向量化器将尝试识别并警告某些类型的不一致。

References

[NQY18]

J. Nothman, H. Qin 和 R. Yurchak (2018). “自由开源软件软件包中的停用词列表”. 在 Proc. Workshop for NLP Open Source Software 中。

8.2.3.5. Tf–idf 项加权#

在大规模文本语料库中，某些词出现的频率非常高（例如英语中的“the”、“a”、“is”），因此承载的关于文档实际内容的意义非常少。如果我们直接将原始计数数据馈送给分类器，那些非常频繁的词会掩盖较稀有但更有意义的词的频率。

为了将计数特征重新加权为适合分类器使用的浮点值，通常使用 tf–idf 转换。

Tf 表示 词频（term-frequency），而 tf–idf 表示词频乘以 逆文档频率（inverse document-frequency）：\(\text{tf-idf(t,d)}=\text{tf(t,d)} \times \text{idf(t)}\)。

使用 TfidfTransformer 的默认设置，即 TfidfTransformer(norm='l2', use_idf=True, smooth_idf=True, sublinear_tf=False)，词频（即一个词在给定文档中出现的次数）会乘以 idf 分量，其计算方式为：

\(\text{idf}(t) = \log{\frac{1 + n}{1+\text{df}(t)}} + 1\),

其中 \(n\) 是文档集中的文档总数，\(\text{df}(t)\) 是文档集中包含词 \(t\) 的文档数量。生成的 tf-idf 向量然后按欧几里得范数进行归一化：

\(v_{norm} = \frac{v}{||v||_2} = \frac{v}{\sqrt{v{_1}^2 + v{_2}^2 + \dots + v{_n}^2}}\).

这最初是为信息检索（作为搜索引擎结果的排序函数）开发的词加权方案，在文档分类和聚类中也得到了很好的应用。

以下章节包含进一步的解释和示例，说明 tf-idf 是如何精确计算的，以及 scikit-learn 的 TfidfTransformer 和 TfidfVectorizer 计算出的 tf-idf 与定义 idf 为下式的标准教材符号有何不同：

\(\text{idf}(t) = \log{\frac{n}{1+\text{df}(t)}}.\)

在 smooth_idf=False 的 TfidfTransformer 和 TfidfVectorizer 中，“1”被添加到 idf 分子中，而不是 idf 的分母中：

\(\text{idf}(t) = \log{\frac{n}{\text{df}(t)}} + 1\)

这种归一化由 TfidfTransformer 类实现。

>>> from sklearn.feature_extraction.text import TfidfTransformer
>>> transformer = TfidfTransformer(smooth_idf=False)
>>> transformer
TfidfTransformer(smooth_idf=False)

同样，请参阅 参考文档 以获取有关所有参数的详细信息。

tf-idf 矩阵的数值示例#

让我们以以下计数为例。第一项出现概率为 100%，因此意义不大。另外两个特征出现的概率不到 50%，因此可能更能代表文档的内容。

>>> counts = [[3, 0, 1],
...           [2, 0, 0],
...           [3, 0, 0],
...           [4, 0, 0],
...           [3, 2, 0],
...           [3, 0, 2]]
...
>>> tfidf = transformer.fit_transform(counts)
>>> tfidf
<Compressed Sparse...dtype 'float64'
  with 9 stored elements and shape (6, 3)>

>>> tfidf.toarray()
array([[0.81940995, 0.        , 0.57320793],
      [1.        , 0.        , 0.        ],
      [1.        , 0.        , 0.        ],
      [1.        , 0.        , 0.        ],
      [0.47330339, 0.88089948, 0.        ],
      [0.58149261, 0.        , 0.81355169]])

每一行都被归一化为具有单位欧几里得范数。

\(v_{norm} = \frac{v}{||v||_2} = \frac{v}{\sqrt{v{_1}^2 + v{_2}^2 + \dots + v{_n}^2}}\)

例如，我们可以按照以下方式计算 counts 数组中第一个文档中第一项的 tf-idf：

\(n = 6\)

\(\text{df}(t)_{\text{term1}} = 6\)

\(\text{idf}(t)_{\text{term1}} = \log \frac{n}{\text{df}(t)} + 1 = \log(1)+1 = 1\)

\(\text{tf-idf}_{\text{term1}} = \text{tf} \times \text{idf} = 3 \times 1 = 3\)

现在，如果我们对文档中的其余 2 项重复此计算，我们得到：

\(\text{tf-idf}_{\text{term2}} = 0 \times (\log(6/1)+1) = 0\)

\(\text{tf-idf}_{\text{term3}} = 1 \times (\log(6/2)+1) \approx 2.0986\)

以及原始 tf-idf 向量：

\(\text{tf-idf}_{\text{raw}} = [3, 0, 2.0986].\)

然后，应用欧几里得 (L2) 范数，我们获得文档 1 的以下 tf-idf：

\(\frac{[3, 0, 2.0986]}{\sqrt{\big(3^2 + 0^2 + 2.0986^2\big)}} = [ 0.819, 0, 0.573].\)

此外，默认参数 smooth_idf=True 将“1”添加到分子和分母中，就好像额外观察到一个包含集合中每个项各一次的文档，这可以防止除以零。

\(\text{idf}(t) = \log{\frac{1 + n}{1+\text{df}(t)}} + 1\)

使用此修改，文档 1 中第三项的 tf-idf 变为 1.8473：

\(\text{tf-idf}_{\text{term3}} = 1 \times \log(7/3)+1 \approx 1.8473\)

L2 归一化的 tf-idf 变为：

\(\frac{[3, 0, 1.8473]}{\sqrt{\big(3^2 + 0^2 + 1.8473^2\big)}} = [0.8515, 0, 0.5243]\):

>>> transformer = TfidfTransformer()
>>> transformer.fit_transform(counts).toarray()
array([[0.85151335, 0.        , 0.52433293],
      [1.        , 0.        , 0.        ],
      [1.        , 0.        , 0.        ],
      [1.        , 0.        , 0.        ],
      [0.55422893, 0.83236428, 0.        ],
      [0.63035731, 0.        , 0.77630514]])

fit 方法计算出的每个特征的权重存储在模型属性中。

>>> transformer.idf_
array([1., 2.25, 1.84])

由于 tf-idf 经常用于文本特征，还有另一个名为 TfidfVectorizer 的类，它将 CountVectorizer 和 TfidfTransformer 的所有选项合并为一个模型。

>>> from sklearn.feature_extraction.text import TfidfVectorizer
>>> vectorizer = TfidfVectorizer()
>>> vectorizer.fit_transform(corpus)
<Compressed Sparse...dtype 'float64'
  with 19 stored elements and shape (4, 9)>

虽然 tf-idf 归一化通常非常有用，但在某些情况下，二进制出现标记可能会提供更好的特征。这可以通过使用 CountVectorizer 的 binary 参数来实现。特别是，一些估计器如 伯努利朴素贝叶斯 明确地建模离散布尔随机变量。此外，非常短的文本很可能具有噪声较大的 tf-idf 值，而二进制出现信息更为稳定。

通常，调整特征提取参数的最佳方法是使用交叉验证的网格搜索，例如将特征提取器与分类器通过流水线连接起来：

示例

8.2.3.6. 解码文本文件#

文本由字符组成，但文件由字节组成。这些字节根据某种 编码 来表示字符。要在 Python 中处理文本文件，它们的字节必须 解码 为称为 Unicode 的字符集。常见的编码包括 ASCII、Latin-1（西欧）、KOI8-R（俄语）以及通用编码 UTF-8 和 UTF-16。还存在许多其他编码。

注意

编码有时也被称为“字符集”，但这个术语不太准确：一个字符集可能存在多种编码。

scikit-learn 中的文本特征提取器知道如何解码文本文件，但前提是您必须告诉它们文件的编码方式。CountVectorizer 为此接受一个 encoding 参数。对于现代文本文件，正确的编码可能是 UTF-8，因此这是默认值（encoding="utf-8"）。

但是，如果您加载的文本实际上不是用 UTF-8 编码的，您将会收到一个 UnicodeDecodeError。可以通过将 decode_error 参数设置为 "ignore" 或 "replace" 来告知向量化器忽略解码错误。有关更多详细信息，请参阅 Python 函数 bytes.decode 的文档（在 Python 提示符下键入 help(bytes.decode)）。

解码文本疑难解答#

如果您在解码文本时遇到问题，可以尝试以下方法：

  • 找出文本的实际编码。文件可能带有告诉您编码的标题或 README，或者根据文本来源，您可以假设某种标准编码。

  • 您可以使用 UNIX 命令 file 找到它的一般编码类型。Python chardet 模块附带了一个名为 chardetect.py 的脚本，可以猜测具体编码，尽管您不能依赖其猜测的准确性。

  • 您可以尝试 UTF-8 并忽略错误。您可以使用 bytes.decode(errors='replace') 解码字节字符串，将所有解码错误替换为无意义字符，或者在向量化器中设置 decode_error='replace'。这可能会损害特征的有效性。

  • 真实的文本可能来自各种来源，可能使用了不同的编码，甚至以与其实际编码不同的编码被草率地解码。这在从 Web 获取的文本中很常见。Python 包 ftfy 可以自动修复某些类别的解码错误，因此您可以尝试将未知文本解码为 latin-1，然后使用 ftfy 修复错误。

  • 如果文本是各种无法理清的编码混合体（20 Newsgroups 数据集就是这种情况），您可以回退到简单的单字节编码，如 latin-1。某些文本可能会显示不正确，但至少相同的字节序列将始终表示相同的特征。

例如，以下片段使用 chardet（不随 scikit-learn 提供，必须单独安装）来找出三个文本的编码。然后它对文本进行向量化并打印学习到的词汇表。此处未显示输出。

>>> import chardet
>>> text1 = b"Sei mir gegr\xc3\xbc\xc3\x9ft mein Sauerkraut"
>>> text2 = b"holdselig sind deine Ger\xfcche"
>>> text3 = b"\xff\xfeA\x00u\x00f\x00 \x00F\x00l\x00\xfc\x00g\x00e\x00l\x00n\x00 \x00d\x00e\x00s\x00 \x00G\x00e\x00s\x00a\x00n\x00g\x00e\x00s\x00,\x00 \x00H\x00e\x00r\x00z\x00l\x00i\x00e\x00b\x00c\x00h\x00e\x00n\x00,\x00 \x00t\x00r\x00a\x00g\x00 \x00i\x00c\x00h\x00 \x00d\x00i\x00c\x00h\x00 \x00f\x00o\x00r\x00t\x00"
>>> decoded = [x.decode(chardet.detect(x)['encoding'])
...            for x in (text1, text2, text3)]
>>> v = CountVectorizer().fit(decoded).vocabulary_
>>> for term in v: print(v)

（取决于 chardet 的版本，它可能会对第一个文本出错。）

有关 Unicode 和字符编码的入门知识，请参阅 Joel Spolsky 的 每个软件开发人员绝对必须知道的 Unicode 知识。

8.2.3.7. 应用与示例#

词袋表示非常简单，但在实践中出人意料地有用。

特别是在 监督学习设置 中，它可以成功地与快速且可扩展的线性模型相结合来训练 文档分类器，例如：

在 无监督学习设置 中，它可以通过应用聚类算法（如 K-means）将相似文档归为一组。

最后，可以通过放宽聚类的硬分配约束来发现语料库的主要主题，例如使用 非负矩阵分解 (NMF 或 NNMF)。

8.2.3.8. 词袋表示的局限性#

Unigrams（即词袋所代表的内容）的集合无法捕获短语和多词表达，有效地忽略了任何单词顺序依赖性。此外，词袋模型不考虑潜在的拼写错误或单词派生。

N-grams 来救援！与其构建简单的 Unigrams（n=1）集合，不如使用 Bigrams（n=2）集合，即计算连续词对的出现次数。

或者，可以考虑字符 n-gram 集合，这是一种能抵御拼写错误和单词派生的表示。

例如，假设我们处理一个包含两个文档的语料库：['words', 'wprds']。第二个文档包含单词“words”的拼写错误。简单的词袋表示会将这两个文档视为非常不同的文档，在所有两个可能的特征上都有所不同。然而，字符 2-gram 表示会发现这两个文档在 8 个特征中有 4 个匹配，这可能有助于首选分类器做出更好的决策。

>>> ngram_vectorizer = CountVectorizer(analyzer='char_wb', ngram_range=(2, 2))
>>> counts = ngram_vectorizer.fit_transform(['words', 'wprds'])
>>> ngram_vectorizer.get_feature_names_out()
array([' w', 'ds', 'or', 'pr', 'rd', 's ', 'wo', 'wp'], ...)
>>> counts.toarray().astype(int)
array([[1, 1, 1, 0, 1, 1, 1, 0],
       [1, 1, 0, 1, 1, 1, 0, 1]])

在上面的示例中，使用了 char_wb 分析器，它仅从单词边界内的字符创建 n-gram（两侧填充空格）。作为替代，char 分析器创建跨越单词的 n-gram。

>>> ngram_vectorizer = CountVectorizer(analyzer='char_wb', ngram_range=(5, 5))
>>> ngram_vectorizer.fit_transform(['jumpy fox'])
<Compressed Sparse...dtype 'int64'
  with 4 stored elements and shape (1, 4)>

>>> ngram_vectorizer.get_feature_names_out()
array([' fox ', ' jump', 'jumpy', 'umpy '], ...)

>>> ngram_vectorizer = CountVectorizer(analyzer='char', ngram_range=(5, 5))
>>> ngram_vectorizer.fit_transform(['jumpy fox'])
<Compressed Sparse...dtype 'int64'
  with 5 stored elements and shape (1, 5)>
>>> ngram_vectorizer.get_feature_names_out()
array(['jumpy', 'mpy f', 'py fo', 'umpy ', 'y fox'], ...)

意识到单词边界的变体 char_wb 对于使用空格进行单词分隔的语言特别有意义，因为它在这种情况下产生的噪声特征比原始 char 变体少得多。对于此类语言，它既能提高分类器的预测准确性，又能提高使用此类特征训练的分类器的收敛速度，同时保持对拼写错误和单词派生的鲁棒性。

虽然可以通过提取 n-gram 而不是单个单词来保留一些局部位置信息，但词袋和 n-gram 袋破坏了文档的大部分内部结构，从而破坏了该内部结构所承载的大部分意义。

为了解决更广泛的自然语言理解任务，因此应考虑到句子和段落的局部结构。许多此类模型将被归类为“结构化输出”问题，这目前超出了 scikit-learn 的范围。

8.2.3.9. 使用哈希技巧对大型文本语料库进行向量化#

上述向量化方案很简单，但它保持 从字符串词到整数特征索引的内存映射（vocabulary_ 属性）这一事实，在 处理大数据集时 会导致几个 问题：

  • 语料库越大，词汇表增长越大，内存使用量也随之增加；

  • 拟合过程需要分配与原始数据集大小成比例的中间数据结构；

  • 构建单词映射需要对数据集进行全遍历，因此无法严格以在线方式拟合文本分类器；

  • 序列化（Pickling）和反序列化带有大 vocabulary_ 的向量化器可能非常慢（通常比序列化/反序列化相同大小的 NumPy 数组等平面数据结构慢得多）；

  • 很难将向量化工作拆分为并发子任务，因为 vocabulary_ 属性必须是具有细粒度同步屏障的共享状态：从词字符串到特征索引的映射取决于每个词第一次出现的顺序，因此必须共享，这可能会损害并发工作者的性能，甚至使其比顺序变体更慢。

通过结合 FeatureHasher 类实现的“哈希技巧”（特征哈希）以及 CountVectorizer 的文本预处理和分词功能，可以克服这些限制。

这种组合在 HashingVectorizer 中实现，这是一个与 CountVectorizer 大部分 API 兼容的转换器类。HashingVectorizer 是无状态的，这意味着您不必对其调用 fit。

>>> from sklearn.feature_extraction.text import HashingVectorizer
>>> hv = HashingVectorizer(n_features=10)
>>> hv.transform(corpus)
<Compressed Sparse...dtype 'float64'
  with 16 stored elements and shape (4, 10)>

您可以看到向量输出中提取了 16 个非零特征词：这少于之前 CountVectorizer 在同一 toy 语料库上提取的 19 个非零值。这种差异是由于 n_features 参数值较低导致的哈希函数冲突所致。

在实际环境中，n_features 参数可以保留其默认值 2 ** 20（大约一百万个可能的特征）。如果内存或下游模型大小是一个问题，选择较低的值（如 2 ** 18）可能会有所帮助，而不会在典型文本分类任务中引入过多的额外冲突。

请注意，维度不会影响对 CSR 矩阵进行操作的算法的 CPU 训练时间（LinearSVC(dual=True), Perceptron, SGDClassifier），但会影响使用 CSC 矩阵的算法（LinearSVC(dual=False), Lasso() 等）。

让我们尝试使用默认设置再做一次：

>>> hv = HashingVectorizer()
>>> hv.transform(corpus)
<Compressed Sparse...dtype 'float64'
  with 19 stored elements and shape (4, 1048576)>

我们不再遇到冲突，但这以输出空间维度更大为代价。当然，除此处使用的 19 个词之外的其他词可能仍然会相互冲突。

HashingVectorizer 还存在以下局限性：

  • 由于执行映射的哈希函数的单向性，无法反转模型（没有 inverse_transform 方法），也无法访问特征的原始字符串表示。

  • 它不提供 IDF 加权，因为那会给模型引入状态。如果需要，可以在流水线中附加一个 TfidfTransformer。

使用 HashingVectorizer 执行核外学习#

使用 HashingVectorizer 的一个有趣进展是能够执行 核外（out-of-core） 缩放。这意味着我们可以从无法装入计算机主内存的数据中学习。

实现核外缩放的一种策略是将数据流式传输到小批量（mini-batches）中的估计器。每个小批量都使用 HashingVectorizer 进行向量化，以确保估计器的输入空间始终具有相同的维度。因此，在任何时间使用的内存量都受限于小批量的大小。尽管使用这种方法可以摄取的数据量没有限制，但从实际角度来看，学习时间通常受限于人们愿意在任务上花费的 CPU 时间。

有关文本分类任务中核外缩放的完整示例，请参阅 文本文档的核外分类。

8.2.3.10. 自定义向量化器类#

可以通过将可调用对象传递给向量化器构造函数来自定义行为：

>>> def my_tokenizer(s):
...     return s.split()
...
>>> vectorizer = CountVectorizer(tokenizer=my_tokenizer)
>>> vectorizer.build_analyzer()(u"Some... punctuation!") == (
...     ['some...', 'punctuation!'])
True

特别是我们命名：

  • preprocessor：一个可调用对象，它接收整个文档作为输入（作为单个字符串），并返回文档可能经过转换的版本，仍然作为整个字符串。这可以用于删除 HTML 标签、将整个文档转换为小写等。

  • tokenizer：一个可调用对象，它接收来自预处理器的输出并将其拆分为词，然后返回这些词的列表。

  • analyzer：一个替代预处理器和分词器的可调用对象。默认分析器都调用预处理器和分词器，但自定义分析器将跳过此步骤。N-gram 提取和停用词过滤发生在分析器级别，因此自定义分析器可能必须重现这些步骤。

（Lucene 用户可能认得这些名称，但请注意，scikit-learn 概念可能无法与 Lucene 概念一一对应。）

为了使预处理器、分词器和分析器能够识别模型参数，可以派生自该类并重写 build_preprocessor、build_tokenizer 和 build_analyzer 工厂方法，而不是传递自定义函数。

技巧和窍门#

  • 如果文档是由外部包预先分词的，则将它们存储在文件中（或字符串中），并将词以空格分隔，然后传递 analyzer=str.split。

  • 诸如词干提取、词形还原、复合词拆分、基于词性过滤等高级词级分析未包含在 scikit-learn 代码库中，但可以通过自定义分词器或分析器来添加。这是一个使用 NLTK 进行分词和词形还原的 CountVectorizer 示例：

    >>> from nltk import word_tokenize
>>> from nltk.stem import WordNetLemmatizer
>>> class LemmaTokenizer:
...     def __init__(self):
...         self.wnl = WordNetLemmatizer()
...     def __call__(self, doc):
...         return [self.wnl.lemmatize(t) for t in word_tokenize(doc)]
...
>>> vect = CountVectorizer(tokenizer=LemmaTokenizer())

    （请注意，这不会过滤掉标点符号。）

    以下示例例如会将某些英式拼写转换为美式拼写：

    >>> import re
>>> def to_british(tokens):
...     for t in tokens:
...         t = re.sub(r"(...)our$", r"\1or", t)
...         t = re.sub(r"([bt])re$", r"\1er", t)
...         t = re.sub(r"([iy])s(e$|ing|ation)", r"\1z\2", t)
...         t = re.sub(r"ogue$", "og", t)
...         yield t
...
>>> class CustomVectorizer(CountVectorizer):
...     def build_tokenizer(self):
...         tokenize = super().build_tokenizer()
...         return lambda doc: list(to_british(tokenize(doc)))
...
>>> print(CustomVectorizer().build_analyzer()(u"color colour"))
[...'color', ...'color']

    对于其他风格的预处理；示例包括词干提取、词形还原或归一化数值标记，后者在以下内容中有所说明：

在处理不使用明确单词分隔符（如空格）的亚洲语言时，自定义向量化器也可能很有用。

8.2.4. 图像特征提取#

8.2.4.1. 补丁（Patch）提取#

extract_patches_2d 函数从存储为二维数组的图像中提取补丁，或者如果是三维数组则在第三轴上包含颜色信息。要从其所有补丁重新构建图像，请使用 reconstruct_from_patches_2d。例如，让我们生成一张具有 3 个颜色通道（例如 RGB 格式）的 4x4 像素图片：

>>> import numpy as np
>>> from sklearn.feature_extraction import image

>>> one_image = np.arange(4 * 4 * 3).reshape((4, 4, 3))
>>> one_image[:, :, 0]  # R channel of a fake RGB picture
array([[ 0,  3,  6,  9],
       [12, 15, 18, 21],
       [24, 27, 30, 33],
       [36, 39, 42, 45]])

>>> patches = image.extract_patches_2d(one_image, (2, 2), max_patches=2,
...     random_state=0)
>>> patches.shape
(2, 2, 2, 3)
>>> patches[:, :, :, 0]
array([[[ 0,  3],
        [12, 15]],

       [[15, 18],
        [27, 30]]])
>>> patches = image.extract_patches_2d(one_image, (2, 2))
>>> patches.shape
(9, 2, 2, 3)
>>> patches[4, :, :, 0]
array([[15, 18],
       [27, 30]])

让我们尝试通过对重叠区域进行平均来从补丁重新构建原始图像：

>>> reconstructed = image.reconstruct_from_patches_2d(patches, (4, 4, 3))
>>> np.testing.assert_array_equal(one_image, reconstructed)

PatchExtractor 类的工作方式与 extract_patches_2d 相同，只是它支持多张图像作为输入。它作为 scikit-learn 转换器实现，因此可以在流水线中使用。请参阅：

>>> five_images = np.arange(5 * 4 * 4 * 3).reshape(5, 4, 4, 3)
>>> patches = image.PatchExtractor(patch_size=(2, 2)).transform(five_images)
>>> patches.shape
(45, 2, 2, 3)

8.2.4.2. 图像的连接图#

scikit-learn 中的几个估计器可以使用特征或样本之间的连接信息。例如，Ward 聚类（层次聚类）只能将图像的相邻像素聚类在一起，从而形成连续的补丁。

../_images/sphx_glr_plot_coin_ward_segmentation_001.png

为此，估计器使用一个“连接”矩阵，给出哪些样本是连接的。

img_to_graph 函数从 2D 或 3D 图像返回这样一个矩阵。类似地，grid_to_graph 根据这些图像的形状为图像构建连接矩阵。

这些矩阵可用于在使用连接信息的估计器中强制连接，例如 Ward 聚类（层次聚类），也用于构建预计算核或相似度矩阵。

注意

示例