改进流Python分类器并结合特征

Posted 2023-03-12

【中文标题】改进流Python分类器并结合特征

【英文标题】：Improve flow Python classifier and combine features

【发布时间】：2017-10-27 16:13:52

【问题描述】：

我正在尝试创建一个分类器来对网站进行分类。我是第一次这样做，所以对我来说这一切都很新鲜。目前我正在尝试在网页的几个部分（例如标题、文本、标题）上做一些词袋。它看起来像这样：

from sklearn.feature_extraction.text import CountVectorizer
countvect_text = CountVectorizer(encoding="cp1252", stop_words="english")
countvect_title = CountVectorizer(encoding="cp1252", stop_words="english")
countvect_headings = CountVectorizer(encoding="cp1252", stop_words="english")

X_tr_text_counts = countvect_text.fit_transform(tr_data['text'])
X_tr_title_counts = countvect_title.fit_transform(tr_data['title'])
X_tr_headings_counts = countvect_headings.fit_transform(tr_data['headings'])

from sklearn.feature_extraction.text import TfidfTransformer

transformer_text = TfidfTransformer(use_idf=True)
transformer_title = TfidfTransformer(use_idf=True)
transformer_headings = TfidfTransformer(use_idf=True)

X_tr_text_tfidf = transformer_text.fit_transform(X_tr_text_counts)
X_tr_title_tfidf = transformer_title.fit_transform(X_tr_title_counts)
X_tr_headings_tfidf = transformer_headings.fit_transform(X_tr_headings_counts)

from sklearn.naive_bayes import MultinomialNB
text_nb = MultinomialNB().fit(X_tr_text_tfidf, tr_data['class'])
title_nb = MultinomialNB().fit(X_tr_title_tfidf, tr_data['class'])
headings_nb = MultinomialNB().fit(X_tr_headings_tfidf, tr_data['class'])

X_te_text_counts = countvect_text.transform(te_data['text'])
X_te_title_counts = countvect_title.transform(te_data['title'])
X_te_headings_counts = countvect_headings.transform(te_data['headings'])

X_te_text_tfidf = transformer_text.transform(X_te_text_counts)
X_te_title_tfidf = transformer_title.transform(X_te_title_counts)
X_te_headings_tfidf = transformer_headings.transform(X_te_headings_counts)

accuracy_text = text_nb.score(X_te_text_tfidf, te_data['class'])
accuracy_title = title_nb.score(X_te_title_tfidf, te_data['class'])
accuracy_headings = headings_nb.score(X_te_headings_tfidf, te_data['class'])

这很好用，而且我得到了预期的准确度。但是，正如您可能已经猜到的那样，这看起来很混乱并且充满了重复。那么我的问题是，有没有办法写得更简洁？

此外，我不确定如何将这三个特征组合成一个单一的多项分类器。我尝试将 tfidf 值列表传递给MultinomialNB().fit()，但显然这是不允许的。

也可以选择为特征添加权重，这样在最终的分类器中，一些向量比其他向量具有更高的重要性。

我猜我需要pipeline，但我完全不确定在这种情况下应该如何使用它。

【参考方案1】：

首先，CountVectorizer 和 TfidfTransformer 可以通过使用TfidfVectorizer（本质上是两者的组合）来移除。

其次，TfidfVectorizer 和 MultinomialNB 可以组合成一个Pipeline。 管道按顺序应用转换列表和最终估计器。当在Pipeline 上调用fit() 时，它会一个接一个地拟合所有转换并转换数据，然后使用最终估计器拟合转换后的数据。而当score() 或predict() 被调用时，它只会在所有变压器上调用transform()，在最后一个上调用score() 或predict()。

所以代码看起来像：

from sklearn.pipeline import Pipeline
pipeline = Pipeline([('vectorizer', TfidfVectorizer(encoding="cp1252",
                                                    stop_words="english",
                                                    use_idf=True)), 
                     ('nb', MultinomialNB())])

accuracy=
for item in ['text', 'title', 'headings']:

    # No need to save the return of fit(), it returns self
    pipeline.fit(tr_data[item], tr_data['class'])

    # Apply transforms, and score with the final estimator
    accuracy[item] = pipeline.score(te_data[item], te_data['class'])

编辑： 编辑以包含所有特征的组合以获得单一准确度：

要组合结果，我们可以采用多种方法。一个很容易理解（但又有点混乱的一面）如下：

# Using scipy to concatenate, because tfidfvectorizer returns sparse matrices
from scipy.sparse import hstack

def get_tfidf(tr_data, te_data, columns):

    train = None
    test = None

    tfidfVectorizer = TfidfVectorizer(encoding="cp1252",
                                      stop_words="english",
                                      use_idf=True)
    for item in columns:
        temp_train = tfidfVectorizer.fit_transform(tr_data[item])
        train = hstack((train, temp_train)) if train is not None else temp_train

        temp_test = tfidfVectorizer.transform(te_data[item])
        test = hstack((test , temp_test)) if test is not None else temp_test

    return train, test

train_tfidf, test_tfidf = get_tfidf(tr_data, te_data, ['text', 'title', 'headings']) 

nb = MultinomialNB()
nb.fit(train_tfidf, tr_data['class'])
nb.score(test_tfidf, te_data['class'])

第二种方法（更可取）是将所有这些都包含在管道中。但是由于选择了不同的列（'text'、'title'、'headings'）并连接结果，它并不是那么简单。我们需要为他们使用 FeatureUnion。特别是以下示例：

http://scikit-learn.org/stable/auto_examples/hetero_feature_union.html#sphx-glr-auto-examples-hetero-feature-union-py

第三，如果你愿意使用其他库，那么 DataFrameMapper from sklearn-pandas 可以简化前面示例中使用的 FeatureUnions 的使用。

如果您确实想走第二种或第三种方式，如果有任何困难，请随时联系。

注意：我还没有检查代码，但它应该可以工作（如果有的话，少一些语法错误）。会尽快在我的电脑上检查。

【讨论】：

感谢您的回复和代码示例！这将返回一个准确度的字典。我有点希望有一种方法可以真正汇集所有功能，并为组合使用功能获得一个准确度分数。还是我看错了？

@BramVanroy 我刚刚简化了您发布的代码。在那你也分别返回了 3 个精度。我们当然可以结合这些功能（事实上这是正确的方法，并且在看到您的代码时想到了为什么不这样做）。看看FeatureUnion

谢谢你，因为这样更简洁！然而，问题的一部分也是我如何将它们变成一个特征（可能带有权重）。我检查了 Pipeline 和 FeatureUnion，但我不知道如何在我的情况下使用它...

@BramVanroy 是的，很抱歉忽略了这一点。我将编辑答案以包含它们。

没问题。同时，我试图查看是否可以通过管道运行多个功能，然后在其上使用 GridSearch，但这也给了我错误。请看这个问题：***.com/questions/44216021/…

【参考方案2】：

下面的 sn-p 是一种简化代码的可能方法：

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.naive_bayes import MultinomialNB

cv = CountVectorizer(encoding="cp1252", stop_words="english")
tt = TfidfTransformer(use_idf=True)
mnb = MultinomialNB()

accuracy = 
for item in ['text', 'title', 'headings']:
    X_tr_counts = cv.fit_transform(tr_data[item])
    X_tr_tfidf = tt.fit_transform(X_tr_counts)
    mnb.fit(X_tr_tfidf, tr_data['class'])
    X_te_counts = cv.transform(te_data[item])
    X_te_tfidf = tt.transform(X_te_counts)
    accuracy[item] = mnb.score(X_te_tfidf, te_data['class'])

分类成功率存储在字典accuracy 中，键为'text、'title' 和'headings'。

编辑

正如@Vivek Kumar 所指出的，一个更优雅的解决方案——虽然不一定更简单——在于使用 Pipeline 和 FeatureUnion。这种方法还允许您将所有特征组合到一个模型中，并对从数据集的不同项目中提取的特征应用加权因子。

首先我们导入必要的模块。

from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import FeatureUnion, Pipeline

然后我们定义一个转换器类（如this example 中所建议的那样）来选择数据集的不同项目：

class ItemSelector(BaseEstimator, TransformerMixin):
    def __init__(self, key):
        self.key = key

    def fit(self, foo, bar=None):
        return self

    def transform(self, data_dict):
        return data_dict[self.key]

我们现在已经准备好定义管道了：

pipeline = Pipeline([
  ('features', FeatureUnion(
    transformer_list=[
      ('text_feats', Pipeline([
        ('text_selector', ItemSelector(key='text')),
        ('text_vectorizer', TfidfVectorizer(encoding="cp1252", 
                                            stop_words="english", 
                                            use_idf=True))
        ])),
      ('title_feats', Pipeline([
        ('title_selector', ItemSelector(key='text')),
        ('title_vectorizer', TfidfVectorizer(encoding="cp1252", 
                                             stop_words="english", 
                                             use_idf=True))
        ])),
      ('headings_feats', Pipeline([
        ('headings_selector', ItemSelector(key='text')),
        ('headings_vectorizer', TfidfVectorizer(encoding="cp1252", 
                                                stop_words="english", 
                                                use_idf=True))
        ])),
    ],
    transformer_weights='text': 0.5,  #change weights as appropriate
                         'title': 0.3,
                         'headings': 0.2
    )),
  ('classifier', MultinomialNB())
])

最后，我们可以直接对数据进行分类：

pipeline.fit(tr_data, tr_data['class'])
pipeline.score(te_data, te_data['class'])