0
0

在NLP中结合文本和数字特征进行机器学习

应用于自然语言处理的机器学习数据通常包含文本和数字输入。例如，当您通过twitter或新闻构建一个模型来预测产品未来的销售时，在考虑文本的同时考虑过去的销售数据、访问者数量、市场趋势等将会更有效。您不会仅仅根据新闻情绪来预测股价的波动，而是会利用它来补充基于经济指标和历史价格的模型。这篇文章展示了如何在scikit-learn（对于Tfidf）和pytorch（对于LSTM / BERT）中组合文本输入和数字输入。

scikit-learn(例如用于Tfidf)

当你有一个包含数字字段和文本的训练dataframe ，并应用一个来自scikit-lean或其他等价的简单模型时，最简单的方法之一是使用sklearn.pipeline的FeatureUnion管道。

下面的示例假定X_train是一个dataframe ，它由许多数字字段和最后一列的文本字段组成。然后，您可以创建一个FunctionTransformer来分隔数字列和文本列。传递给这个FunctionTransformer的函数可以是任何东西，因此请根据输入数据修改它。这里它只返回最后一列作为文本特性，其余的作为数字特性。然后在文本上应用Tfidf矢量化并输入分类器。该样本使用RandomForest作为估计器，并使用GridSearchCV在给定参数中搜索最佳模型，但它可以是其他任何参数。

  1.  import numpy as np
  2.  from sklearn.feature_extraction.text import TfidfVectorizer
  3.  from sklearn.pipeline import Pipeline, FeatureUnion
  4.  from sklearn.ensemble import RandomForestClassifier
  5.  from sklearn.preprocessing import FunctionTransformer
  6.  from sklearn.model_selection import GridSearchCV, StratifiedKFold
  7.  
  8.  # Create Function Transformer to use Feature Union
  9.  def get_numeric_data(x):
  10.      return [record[:-2].astype(float) for record in x]
  11.  
  12.  def get_text_data(x):
  13.      return [record[-1] for record in x]
  14.  
  15.  transfomer_numeric = FunctionTransformer(get_numeric_data)
  16.  transformer_text = FunctionTransformer(get_text_data)
  17.  
  18.  # Create a pipeline to concatenate Tfidf Vector and Numeric data
  19.  # Use RandomForestClassifier as an example
  20.  pipeline = Pipeline([
  21.      ('features', FeatureUnion([
  22.              ('numeric_features', Pipeline([
  23.                  ('selector', transfomer_numeric)
  24.              ])),
  25.               ('text_features', Pipeline([
  26.                  ('selector', transformer_text),
  27.                  ('vec', TfidfVectorizer(analyzer='word'))
  28.              ]))
  29.           ])),
  30.      ('clf', RandomForestClassifier())
  31.  ])
  32.  
  33.  # Grid Search Parameters for RandomForest
  34.  param_grid = {'clf__n_estimators': np.linspace(1, 100, 10, dtype=int),
  35.                'clf__min_samples_split': [3, 10],
  36.                'clf__min_samples_leaf': [3],
  37.                'clf__max_features': [7],
  38.                'clf__max_depth': [None],
  39.                'clf__criterion': ['gini'],
  40.                'clf__bootstrap': [False]}
  41.  
  42.  # Training config
  43.  kfold = StratifiedKFold(n_splits=7)
  44.  scoring = {'Accuracy': 'accuracy', 'F1': 'f1_macro'}
  45.  refit = 'F1'
  46.  
  47.  # Perform GridSearch
  48.  rf_model = GridSearchCV(pipeline, param_grid=param_grid, cv=kfold, scoring=scoring, 
  49.                           refit=refit, n_jobs=-1, return_train_score=True, verbose=1)
  50.  rf_model.fit(X_train, Y_train)
  51.  rf_best = rf_model.best_estimator_

Scikit-learn提供了很好的api来管理ML管道，它只完成工作，还可以以同样的方式执行更复杂的步骤。

Pytorch(例如LSTM, BERT)

如果您应用深度神经网络，更常见的是使用Tensorflow/Keras或Pytorch来定义层。两者都有类似的api，并且可以以相同的方式组合文本和数字输入，下面的示例使用pytorch。

要在神经网络中处理文本，首先它应该以模型所期望的方式嵌入。有一个dropout 层也是常见的，以避免过拟合。该模型在与数字特征连接之前添加一个稠密层(即全连接层)，以平衡特征的数量。最后，应用稠密层输出所需的输出数量。

  1.  class LSTMTextClassifier(nn.Module):
  2.    def __init__(self, vocab_size, embed_size, lstm_size, dense_size, numeric_feature_size, output_size, lstm_layers=1, dropout=0.1):
  3.          super().__init__()
  4.          self.vocab_size = vocab_size
  5.          self.embed_size = embed_size
  6.          self.lstm_size = lstm_size
  7.          self.output_size = output_size
  8.          self.lstm_layers = lstm_layers
  9.          self.dropout = dropout
  10.  
  11.          self.embedding = nn.Embedding(vocab_size, embed_size)
  12.          self.lstm = nn.LSTM(embed_size, lstm_size, lstm_layers, dropout=dropout, batch_first=False)
  13.          self.dropout = nn.Dropout(0.2)
  14.          self.fc1 = nn.Linear(lstm_size, dense_size)
  15.          self.fc2 = nn.Linear(dense_size + numeric_feature_size, output_size)
  16.          self.softmax = nn.LogSoftmax(dim=1)
  17.  
  18.      def init_hidden(self, batch_size):
  19.          weight = next(self.parameters()).data
  20.          hidden = (weight.new(self.lstm_layers, batch_size, self.lstm_size).zero_(),
  21.                    weight.new(self.lstm_layers, batch_size, self.lstm_size).zero_())
  22.          
  23.          return hidden
  24.  
  25.      def forward(self, nn_input_text, nn_input_meta, hidden_state):
  26.          batch_size = nn_input_text.size(0)
  27.          nn_input_text = nn_input_text.long()
  28.          embeds = self.embedding(nn_input_text)
  29.          lstm_out, hidden_state = self.lstm(embeds, hidden_state)
  30.          lstm_out = lstm_out[-1,:,:]
  31.          lstm_out = self.dropout(lstm_out)
  32.          dense_out = self.fc1(lstm_out)
  33.          concat_layer = torch.cat((dense_out, nn_input_meta.float()), 1)
  34.          out = self.fc2(concat_layer)
  35.          logps = self.softmax(out)
  36.  
  37.          return logps, hidden_state
  38.        
  39.  class BertTextClassifier(nn.Module):
  40.      def __init__(self, hidden_size, dense_size, numeric_feature_size, output_size, dropout=0.1):
  41.          super().__init__()
  42.          self.output_size = output_size
  43.          self.dropout = dropout
  44.          
  45.          # Use pre-trained BERT model
  46.          self.bert = BertModel.from_pretrained('bert-base-uncased', output_hidden_states=True, output_attentions=True)
  47.          for param in self.bert.parameters():
  48.              param.requires_grad = True
  49.          self.weights = nn.Parameter(torch.rand(13, 1))
  50.          self.dropout = nn.Dropout(dropout)
  51.          self.fc1 = nn.Linear(hidden_size, dense_size)
  52.          self.fc2 = nn.Linear(dense_size + numeric_feature_size, output_size)
  53.          self.softmax = nn.LogSoftmax(dim=1)
  54.  
  55.      def forward(self, input_ids, nn_input_meta):        
  56.          all_hidden_states, all_attentions = self.bert(input_ids)[-2:]
  57.          batch_size = input_ids.shape[0]
  58.          ht_cls = torch.cat(all_hidden_states)[:, :1, :].view(13, batch_size, 1, 768)
  59.          atten = torch.sum(ht_cls * self.weights.view(13, 1, 1, 1), dim=[1, 3])
  60.          atten = F.softmax(atten.view(-1), dim=0)
  61.          feature = torch.sum(ht_cls * atten.view(13, 1, 1, 1), dim=[0, 2])
  62.          dense_out = self.fc1(self.dropout(feature))
  63.          concat_layer = torch.cat((dense_out, nn_input_meta.float()), 1)
  64.          out = self.fc2(concat_layer)
  65.          logps = self.softmax(out)
  66.  
  67.          return logps

以上代码在前向传播时使用torch.cat将数字特征和文本特征进行组合，并输入到后续的分类器中进行处理。

作者：Yuki Takahashi

原文地址：https://towardsdatascience.com/how-to-combine-textual-and-numerical-features-for-machine-learning-in-python-dc1526ca94d9

deephub翻译组

标签：
登录后发布评论

“在NLP中结合文本和数字特征进行机器学习”的评论:

还没有评论
关于作者
...
Deephub
更多文章请关注公众号：Deephub-IMBA
相关阅读

Crawl4AI：为大语言模型打造的开源网页数据采集工具

Triton入门教程：安装与编写和运行简单Triton内核

用离散标记重塑人体姿态：VQ-VAE实现关键点组合关系编码

MCP与A2A协议比较：人工智能系统互联与协作的技术基础架构

比扩散策略更高效的生成模型：流匹配的理论基础与Pytorch代码实现

从零实现基于扩散模型的文本到视频生成系统：技术详解与Pytorch代码实现

18个常用的强化学习算法整理：从基础方法到高级模型的理论技术与代码实现