multilabel?

Почему? Просто погуглите multilabel classification

Лейблы единичные, на выходных нейронах просто не надо делать софтмакс

Не нужно в 1 суммировать при miltilabel
Сигмоида на каждый выход и вперёд страдать с балансом классов

Спасибо!)

Почитаю

BCEWithLogits

BERT вам выдает векторное представление для каждого токена.

text = 'I am a toxic AND grateful comment to the movie'
text = '[CLS] ' + text + ' [SEP']

Как правило, в задачах классификации (не важно мульти или сингл) - используют представление соответствующее токену '[CLS]'.
Дальше вы можете крутить все, что хотите, т.е. если по-программерски говояр:

def prediction(text):
   encoded = config.TOKENIZER.encode_plus(
       text,
       add_special_tokens=True,
       max_length=config.MAX_LEN,
       pad_to_max_length=True,
       return_attention_mask=True
   )
   ids = torch.tensor(encoded['input_ids'], dtype=torch.long).unsqueeze(0)
   masks = torch.tensor(encoded['attention_mask'], dtype=torch.long).unsqueeze(0)
   t_id = torch.tensor(encoded['token_type_ids'], dtype=torch.long).unsqueeze(0)
   ids = ids.to(device, dtype=torch.long)
   masks = masks.to(device, dtype=torch.long)
   t_id = t_id.to(device, dtype=torch.long)
   with torch.no_grad():
       # Получаем BERT embedding
       output = model(
           ids=ids,
           masks=masks,
           token_type_ids=t_id
       )
       # Здесь прикручиваем сколько хотим слоев классификации. С какой хотим архитектурой
       return torch.sigmoid(output).cpu().detach().numpy()

Большое большое спасибо!

text = 'I am a toxic AND grateful comment to the movie'
text = '[CLS] ' + text + ' [SEP']

а где здесь сама модель BERT?

import torch.nn as nn
from transformers import BertModel as BM

class BertBaseUncased(nn.Module):
   def __init__(self, PATH_TO_MODEL: str):
       super().__init__()
       self.model = BM.from_pretrained(PATH_TO_MODEL)
       # Дальше идет ваш классифайер какой хотите
       self.drop_me = nn.Dropout(0.15)
       self.klass_me = nn.Linear(768, 1)

   def forward(self, ids,  masks, token_type_ids):
       _, output = self.model(ids, attention_mask=masks, token_type_ids=token_type_ids)
       me = self.drop_me(output)
       out = self.klass_me(me)
       return out

model = BertBaseUncased(<PATH_TO_MODEL>)

теперь понятно

то есть для классификации берется первый эмбеддинг фразы?

Ага, соответствующий [CLS], который вы дообучили перед этим

class TextClassifier(pl.LightningModule):
    def __init__(self, hparams):
        super().__init__()
        self.hparams = hparams

        self.loss_f = nn.BCEWithLogitsLoss()
        self.class_names = hparams.class_names

        self.bert = AutoModel.from_pretrained(hparams.bert_model)

        self.decoder = nn.Sequential(
            nn.Dropout(hparams.dropout_rate),
            nn.Linear(hparams.hidden_size * 2, hparams.num_classes)
            )

    def forward(self, input_ids, attention_mask):
        h, _ = self.bert(input_ids=input_ids,
                         attention_mask=attention_mask,
                         output_attentions=None)


        h_max = torch.max(h[:, 1:], dim=1).values
        h_avg = torch.mean(h[:, 1:], dim=1)
        # h_cls = h[:, 0]

        encoded = torch.cat([h_max, h_avg], dim=1)
        # encoded_dropped = self.dropout(encoded)

        
        logits = self.decoder(encoded).squeeze()
        return logits

    def training_step(self, batch, batch_idx):
        logits = self.forward(
            batch['input_ids'],
            batch['attention_mask'],
        )

        loss = self.loss_f(logits, batch['labels'])
        self.log('train_loss', loss, on_step=True, on_epoch=False, prog_bar=True, logger=True)
        return loss

    def configure_optimizers(self):
        no_decay = ['bias', 'LayerNorm.weight']
        optimizer_grouped_parameters = [
            {'params': [p for n, p in self.bert.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 0.01},
            {'params': [p for n, p in self.bert.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},
            {'params': self.decoder.parameters()}
        ]


        opt = AdamW(
            optimizer_grouped_parameters,
            lr=self.hparams.learning_rate
            )
        return opt

Как-то так это может выглядеть, если юзять PytorchLighting

Я бы посоветовал один раз самому написать, чтобы понимать, что берётся от Берта и что с этим делается

По [CLS] классифицировать не надо, он говно

Если совсем тяжко со своими модельками, то на быстренько посмотреть можно заюзать:
https://github.com/ThilinaRajapakse/simpletransformers

Там только csv сформировать как он хочет, остальное даже как-то работает из коробки само

То есть весь мультилэйбл будет выглядеть вот так

https://github.com/ThilinaRajapakse/simpletransformers/blob/master/examples/text_classification/multilabel_classification.py

А не вот это вот всё

да сейчас и сам Huggingface не очень сложный стал, в четвертой версии

после того как они сделали Trainer