Question

作为研究项目的一部分，我想选择预处理技术和文本功能的 best 最佳组合，它们可以优化文本分类任务的结果。为此，我使用的是Python 3.6。

有很多方法可以将特征和算法结合起来，但是我想充分利用sklearn的流水线，并使用网格搜索的最终特征组合来测试所有不同的（有效）可能性。

我的第一步是建立一个如下所示的管道：

# Run a vectorizer with a predefined tweet tokenizer and a Naive Bayes

pipeline = Pipeline([
    ('vectorizer', CountVectorizer(tokenizer = tweet_tokenizer)),
    ('nb', MultinomialNB())
])

parameters = {
'vectorizer__preprocessor': (None, preprocessor)
}

gs =  GridSearchCV(pipeline, parameters, cv=5, n_jobs=-1, verbose=1)

在这个简单的示例中，矢量化器使用tweet_tokenizer对数据进行令牌化，然后测试哪种预处理选项（无或预定义的函数）效果更好。

这似乎是一个不错的开始，但是我现在正在努力寻找一种方法来测试预处理器功能（定义如下）中的所有不同可能性：

def preprocessor(tweet):
    # Data cleaning
    tweet = URL_remover(tweet) # Removing URLs
    tweet = mentions_remover(tweet) # Removing mentions
    tweet = email_remover(tweet) # Removing emails
    tweet = irrelev_chars_remover(tweet) # Removing invalid chars
    tweet = emojies_converter(tweet) # Translating emojies
    tweet = to_lowercase(tweet) # Converting words to lowercase
    # Others
    tweet = hashtag_decomposer(tweet) # Hashtag decomposition
    # Punctuation may only be removed after hashtag decomposition  
    # because it considers "#" as punctuation
    tweet = punct_remover(tweet) # Punctuation 
    return tweet

结合所有不同处理技术的“简单”解决方案将是为每种可能性创建不同的功能（例如funcA：proc1，funcB：proc1 + proc2，funcC：proc1 + proc3等）并设置网格参数如下：

parameters = {
   'vectorizer__preprocessor': (None, funcA, funcB, funcC, ...)
}

尽管这很可能行得通，但这对于该任务而言不是可行或合理的解决方案，尤其是因为存在2^n_features个不同的组合以及相应的功能。

最终目标是在管道中结合预处理技术和功能，以便使用gridsearch优化分类结果：

pipeline = Pipeline([
    ('vectorizer', CountVectorizer(tokenizer = tweet_tokenizer)),
    ('feat_extractor' , feat_extractor)
    ('nb', MultinomialNB())
])

 parameters = {
   'vectorizer__preprocessor': (None, funcA, funcB, funcC, ...)
   'feat_extractor': (None, func_A, func_B, func_C, ...)
 }

有没有更简单的方法来获得这个？

Answer 1

根据您的描述，此解决方案非常粗糙，具体取决于答案，具体取决于所使用的数据类型。在建立管道之前，让我们了解CountVectorizer在传递到其中的raw_documents上如何工作。本质上，this is the line将字符串文档处理为令牌

return lambda doc: self._word_ngrams(tokenize(preprocess(self.decode(doc))), stop_words)

然后将它们计数并转换为计数矩阵。

所以这里发生的是：

decode：只需决定如何从文件中读取数据（如果已指定）。对我们来说没有用，因为我们已经将数据放入列表中。
preprocess：如果'strip_accents'中的'lowercase'和True是CountVectorizer，则执行以下操作。没什么
```
strip_accents(x.lower())
```
同样，没有用，因为我们将小写功能移到了我们自己的预处理器上，并且不需要剥离重音，因为我们已经在字符串列表中有了数据。
tokenize：将删除所有标点符号，仅保留长度为2或更大的字母数字单词，并返回单个文档的标记列表（列表元素）
```
lambda doc: token_pattern.findall(doc)
```
请记住这一点。如果您想自己处理标点符号和其他符号（决定保留一些标点符号并删除其他符号），则最好更改token_pattern=’(?u)\b\w\w+\b’的默认CountVectorizer。
1. _word_ngrams：此方法将首先从上一步的标记列表中删除停用词（作为上述参数提供），然后根据{{中的ngram_range参数定义的n_grams 1}}。如果您要以自己的方式处理CountVectorizer，也应牢记这一点。

注意：如果分析仪设置为"n_grams"，则将不执行'char'步骤，并且将由字符组成n_gram。

现在进入我们的管道。这是我认为可以在此处使用的结构：

tokenizer

现在要编写代码。这就是管道的样子：

X --> combined_pipeline, Pipeline
            |
            |  Raw data is passed to Preprocessor
            |
            \/
         Preprocessor 
                 |
                 |  Cleaned data (still raw texts) is passed to FeatureUnion
                 |
                 \/
              FeatureUnion
                      |
                      |  Data is duplicated and passed to both parts
       _______________|__________________
      |                                  |
      |                                  |                         
      \/                                \/
   CountVectorizer                  FeatureExtractor
           |                                  |   
           |   Converts raw to                |   Extracts numerical features
           |   count-matrix                   |   from raw data
           \/________________________________\/
                             |
                             | FeatureUnion combines both the matrices
                             |
                             \/
                          Classifier

其中# Imports from sklearn.svm import SVC from sklearn.pipeline import FeatureUnion, Pipeline # Pipeline pipe = Pipeline([('preprocessor', CustomPreprocessor()), ('features', FeatureUnion([("vectorizer", CountVectorizer()), ("extractor", CustomFeatureExtractor()) ])) ('classifier', SVC()) ])和CustomPreprocessor的定义为：

CustomFeatureExtractor

最后，现在可以像下面这样轻松完成参数网格了：

from sklearn.base import TransformerMixin, BaseEstimator

class CustomPreprocessor(BaseEstimator, TransformerMixin):
    def __init__(self, remove_urls=True, remove_mentions=True, 
                 remove_emails=True, remove_invalid_chars=True, 
                 convert_emojis=True, lowercase=True, 
                 decompose_hashtags=True, remove_punctuations=True):
        self.remove_urls=remove_urls
        self.remove_mentions=remove_mentions
        self.remove_emails=remove_emails
        self.remove_invalid_chars=remove_invalid_chars
        self.convert_emojis=convert_emojis
        self.lowercase=lowercase
        self.decompose_hashtags=decompose_hashtags
        self.remove_punctuations=remove_punctuations

    # You Need to have all the functions ready
    # This method works on single tweets
    def preprocessor(self, tweet):
        # Data cleaning
        if self.remove_urls:
            tweet = URL_remover(tweet) # Removing URLs

        if self.remove_mentions:
            tweet = mentions_remover(tweet) # Removing mentions

        if self.remove_emails:
            tweet = email_remover(tweet) # Removing emails

        if self.remove_invalid_chars:
            tweet = irrelev_chars_remover(tweet) # Removing invalid chars

        if self.convert_emojis:
            tweet = emojies_converter(tweet) # Translating emojies

        if self.lowercase:
            tweet = to_lowercase(tweet) # Converting words to lowercase

        if self.decompose_hashtags:
            # Others
            tweet = hashtag_decomposer(tweet) # Hashtag decomposition

        # Punctuation may only be removed after hashtag decomposition  
        # because it considers "#" as punctuation
        if self.remove_punctuations:
            tweet = punct_remover(tweet) # Punctuation 

        return tweet

    def fit(self, raw_docs, y=None):
        # Noop - We dont learn anything about the data
        return self

    def transform(self, raw_docs):
        return [self.preprocessor(tweet) for tweet in raw_docs]

from textblob import TextBlob
import numpy as np
# Same thing for feature extraction
class CustomFeatureExtractor(BaseEstimator, TransformerMixin):
    def __init__(self, sentiment_analysis=True, tweet_length=True):
        self.sentiment_analysis=sentiment_analysis
        self.tweet_length=tweet_length

    # This method works on single tweets
    def extractor(self, tweet):
        features = []

        if self.sentiment_analysis:
            blob = TextBlob(tweet)
            features.append(blob.sentiment.polarity)

        if self.tweet_length:
            features.append(len(tweet))

        # Do for other features you want.

        return np.array(features)

    def fit(self, raw_docs, y):
        # Noop - Again I am assuming that We dont learn anything about the data
        # Definitely not for tweet length, and also not for sentiment analysis
        # Or any other thing you might have here.
        return self

    def transform(self, raw_docs):
        # I am returning a numpy array so that the FeatureUnion can handle that correctly
        return np.vstack(tuple([self.extractor(tweet) for tweet in raw_docs]))

上面的代码是避免使用“ param_grid = ['preprocessor__remove_urls':[True, False], 'preprocessor__remove_mentions':[True, False], ... ... # No need to search for lowercase or preprocessor in CountVectorizer 'features__vectorizer__max_df':[0.1, 0.2, 0.3], ... ... 'features__extractor__sentiment_analysis':[True, False], 'features__extractor__tweet_length':[True, False], ... ... 'classifier__C':[0.01, 0.1, 1.0] ]”。只需执行True，False和GridSearchCV即可处理。

更新：如果您不想使用to create a different function for each possibility (e.g. funcA: proc1, funcB: proc1 + proc2, funcC: proc1 + proc3, etc.)，则可以将其从管道和参数网格中删除，新管道将为：

CountVectorizer

然后确保在pipe = Pipeline([('preprocessor', CustomPreprocessor()), ("extractor", CustomFeatureExtractor()), ('classifier', SVC()) ])中实现所需的所有功能。如果这变得太复杂，那么您总是可以制作更简单的提取器，并在FeatureUnion中将它们组合在一起，以代替CustomFeatureExtractor

使用管道和网格搜索执行特征选择

1 个答案: