1

我正在尝试解决多类文本分类问题。由于我的项目的特定要求，我正在尝试使用 skorch ( https://skorch.readthedocs.io/en/stable/index.html ) 为 sklearn 管道包装 pytorch。我想做的是用我的数据集微调来自 Huggingface ( https://huggingface.co ) 的 BERT 的预训练版本。据我所知，我已经尝试遵循 skorch 的说明，了解我应该如何输入数据、构建模型等。在训练期间，火车损失仍在减少，直到第 8 个时期开始波动，而一直验证损失从一开始就增加，验证准确度保持恒定为零。我的管道设置是

    from sklearn.pipeline import Pipeline


    pipeline = Pipeline(
    [
        ("tokenizer", Tokenizer()),
        ("classifier", _get_new_transformer())
    ]

在其中我使用标记器类来预处理我的数据集，为 BERT 标记它并创建注意掩码。看起来像这样

    import torch
    from transformers import AutoTokenizer, AutoModel
    from torch import nn
    import torch.nn.functional as F
    from sklearn.base import BaseEstimator, TransformerMixin
    from tqdm import tqdm
    import numpy as np


    class Tokenizer(BaseEstimator, TransformerMixin):
        def __init__(self):
            super(Tokenizer, self).__init__()

            self.tokenizer = AutoTokenizer.from_pretrained(/path/to/model)

        def _tokenize(self, X, y=None):
            tokenized = self.tokenizer.encode_plus(X, max_length=20, add_special_tokens=True, pad_to_max_length=True)
            tokenized_text = tokenized['input_ids']
            attention_mask = tokenized['attention_mask']
            return np.array(tokenized_text), np.array(attention_mask)


        def fit(self, X, y=None):
            return self

        def transform(self, X, y=None):
            word_tokens, attention_tokens = np.array([self._tokenize(string)[0] for string in tqdm(X)]), \
                                    np.array([self._tokenize(string)[1] for string in tqdm(X)])
            X = word_tokens, attention_tokens
            return X

        def fit_transform(self, X, y=None, **fit_params):
            self = self.fit(X, y)
            return self.transform(X, y)

然后我初始化我想要微调的模型

    class Transformer(nn.Module):
        def __init__(self, num_labels=213, dropout_proba=.1):
            super(Transformer, self).__init__()

            self.num_labels = num_labels
            self.model = AutoModel.from_pretrained(/path/to/model)
            self.dropout = torch.nn.Dropout(dropout_proba)
            self.classifier = torch.nn.Linear(768, num_labels)


        def forward(self, X, **kwargs):
            X_tokenized, attention_mask = torch.stack([x.unsqueeze(0) for x in X[0]]),\
                                  torch.stack([x.unsqueeze(0) for x in X[1]])
            _, X = self.model(X_tokenized.squeeze(), attention_mask.squeeze())
            X = F.relu(X)
            X = self.dropout(X)
            X = self.classifier(X)
            return X

我初始化模型并使用 skorch 创建分类器，如下所示

    from skorch import NeuralNetClassifier
    from skorch.dataset import CVSplit
    from skorch.callbacks import ProgressBar
    import torch
    from transformers import AdamW


    def _get_new_transformer() -> NeuralNetClassifier:
        transformer = Transformer()
        net = NeuralNetClassifier(
            transformer,
            lr=2e-5,
            max_epochs=10,
            criterion=torch.nn.CrossEntropyLoss,
            optimizer=AdamW,
            callbacks=[ProgressBar(postfix_keys=['train_loss', 'valid_loss'])],
            train_split=CVSplit(cv=2, random_state=0)
            )
            return net

我像这样使用fit

   pipeline.fit(X=dataset.training_samples, y=dataset.training_labels)

其中我的训练样本是字符串列表，我的标签是包含每个类的索引的数组，如 pytorch 所要求的。

这是发生的事情的一个示例

训练历史

我试图只训练全连接层而不是 BERT，但我又遇到了同样的问题。我还在训练过程之后测试了训练的准确率，它只有 0.16%。对于如何解决我的问题的任何建议或见解，我将不胜感激！我对 skorch 很陌生，对 pytorch 还不太熟悉，我相信我错过了一些非常简单的东西。非常感谢您！

4

0 回答 0