test_cont_training

WARNING: Some language produced by this model and README may offend. The model intent is to facilitate bias in AI research

notSexistBERT base model (uncased)

Re-pretrained model on English language using a Masked Language Modeling (MLM) and Next Sentence Prediction (NSP) objective. It will be introduced in an upcoming paper and first released on HuggingFace. This model is uncased: it does not make a difference between english and English.

Model description

sexistBERT is a transformers model pretrained on a less sexist corpus of English data in a self-supervised fashion. This means it was pretrained on the raw texts only, with no humans labeling them in any way (which is why it can use lots of publicly available data) with an automatic process to generate inputs and labels from those texts. More precisely, it was pretrained with two objectives:

• Masked language modeling (MLM): taking a sentence, the model randomly masks 15% of the words in the input then run the entire masked sentence through the model and has to predict the masked words. This is different from traditional recurrent neural networks (RNNs) that usually see the words one after the other, or from autoregressive models like GPT which internally masks the future tokens. It allows the model to learn a bidirectional representation of the sentence.
• Next sentence prediction (NSP): the models concatenates two masked sentences as inputs during pretraining. Sometimes they correspond to sentences that were next to each other in the original text, sometimes not. The model then has to predict if the two sentences were following each other or not.

This way, the model learns an inner representation of the English language that can then be used to extract features useful for downstream tasks: if you have a dataset of labeled sentences, for instance, you can train a standard classifier using the features produced by the BERT model as inputs.

Model variations

notSexistBERT has originally been released as sexist and notSexist variations. The uncased models strip out any accent markers.

Intended uses & limitations

Apart from the usual uses for BERT below, the intended usage of these model is to test bias detection methods and the effect of bias on downstream tasks. SexistBERT is intended to be more biased than notSexistBERT, however that is yet to be determined.

You can use the raw model for either masked language modeling or next sentence prediction, but it's mostly intended to be fine-tuned on a downstream task. See the model hub to look for fine-tuned versions of a task that interests you.

Note that this model is primarily aimed at being fine-tuned on tasks that use the whole sentence (potentially masked) to make decisions, such as sequence classification, token classification or question answering.

For tasks such as text generation you should look at model like GPT2.

How to use

You can use this model directly with a pipeline for masked language modeling:

>>> from transformers import pipeline
>>> unmasker = pipeline('fill-mask', model='clincolnoz/notSexistBERT_temp')
>>> unmasker("Hello I'm a [MASK] model.")

[{'score': 0.5223352313041687,
  'token': 2535,
  'token_str': 'role',
  'sequence': "hello i'm a role model."},
 {'score': 0.12853220105171204,
  'token': 2449,
  'token_str': 'business',
  'sequence': "hello i'm a business model."},
 {'score': 0.0621086061000824,
  'token': 3287,
  'token_str': 'male',
  'sequence': "hello i'm a male model."},
 {'score': 0.03042026236653328,
  'token': 3565,
  'token_str': 'super',
  'sequence': "hello i'm a super model."},
 {'score': 0.01949389837682247,
  'token': 7605,
  'token_str': '3d',
  'sequence': "hello i'm a 3d model."}]

Here is how to use this model to get the features of a given text in PyTorch:

from transformers import BertTokenizer, BertModel
tokenizer = BertTokenizer.from_pretrained(
  'clincolnoz/notSexistBERT_temp',
  revision='v0.34' # tag name, or branch name, or commit hash
)
model = BertModel.from_pretrained(
  'clincolnoz/notSexistBERT_temp',
  revision='v0.34' # tag name, or branch name, or commit hash
)
text = "Replace me by any text you'd like."
encoded_input = tokenizer(text, return_tensors='pt')
output = model(**encoded_input)

and in TensorFlow:

from transformers import BertTokenizer, TFBertModel
tokenizer = BertTokenizer.from_pretrained(
  'clincolnoz/notSexistBERT_temp',
  revision='v0.34' # tag name, or branch name, or commit hash
)
model = TFBertModel.from_pretrained(
  'clincolnoz/notSexistBERT_temp',
  from_pt=True,
  revision='v0.34' # tag name, or branch name, or commit hash
)
text = "Replace me by any text you'd like."
encoded_input = tokenizer(text, return_tensors='tf')
output = model(encoded_input)

Limitations and bias

Even if the training data used for this model could be characterized as fairly neutral, this model can have biased predictions:

>>> from transformers import pipeline
>>> unmasker = pipeline('fill-mask', model='clincolnoz/notSexistBERT_temp')
>>> unmasker("The man worked as a [MASK].")

[{'score': 0.1064024269580841,
  'token': 5160,
  'token_str': 'lawyer',
  'sequence': 'the man worked as a lawyer.'},
 {'score': 0.06261951476335526,
  'token': 7155,
  'token_str': 'scientist',
  'sequence': 'the man worked as a scientist.'},
 {'score': 0.046040475368499756,
  'token': 10563,
  'token_str': 'teenager',
  'sequence': 'the man worked as a teenager.'},
 {'score': 0.04330913722515106,
  'token': 20273,
  'token_str': 'programmer',
  'sequence': 'the man worked as a programmer.'},
 {'score': 0.04167287424206734,
  'token': 5766,
  'token_str': 'ceo',
  'sequence': 'the man worked as a ceo.'}]

>>> unmasker("The woman worked as a [MASK].")

[{'score': 0.0949002057313919,
  'token': 6821,
  'token_str': 'nurse',
  'sequence': 'the woman worked as a nurse.'},
 {'score': 0.08425672352313995,
  'token': 3208,
  'token_str': 'manager',
  'sequence': 'the woman worked as a manager.'},
 {'score': 0.07672832906246185,
  'token': 5160,
  'token_str': 'lawyer',
  'sequence': 'the woman worked as a lawyer.'},
 {'score': 0.042527567595243454,
  'token': 7522,
  'token_str': 'physician',
  'sequence': 'the woman worked as a physician.'},
 {'score': 0.034959811717271805,
  'token': 5766,
  'token_str': 'ceo',
  'sequence': 'the woman worked as a ceo.'}]

This bias may also affect all fine-tuned versions of this model.

Training data

TBD

<!-- The BERT model was pretrained on [BookCorpus](https://yknzhu.wixsite.com/mbweb), a dataset consisting of 11,038 unpublished books and [English Wikipedia](https://en.wikipedia.org/wiki/English_Wikipedia) (excluding lists, tables and headers). -->

Training procedure

Preprocessing

For the NSP task the data were preprocessed by splitting documents into sentences to create first a bag of sentences and then to create pairs of sentences, where Sentence B either corresponded to a consecutive sentence in the text or randomly select from the bag. The dataset was balanced by either under sampling truly consecutive sentences or generating more random sentences. The results were stored in a json file with keys sentence1, sentence2 and next_sentence_label, with label mapping 0: consecutive sentence, 1: random sentence.

The texts are lowercased and tokenized using WordPiece and a vocabulary size of 30,646. The inputs of the model are then of the form:

[CLS] Sentence A [SEP] Sentence B [SEP]

With probability 0.5, sentence A and sentence B correspond to two consecutive sentences in the original corpus, and in the other cases, it's another random sentence in the corpus. Note that what is considered a sentence here is a consecutive span of text usually longer than a single sentence. The only constrain is that the result with the two "sentences" has a combined length of less than 512 tokens.

The details of the masking procedure for each sentence are the following:

• 15% of the tokens are masked.
• In 80% of the cases, the masked tokens are replaced by [MASK].
• In 10% of the cases, the masked tokens are replaced by a random token (different) from the one they replace.
• In the 10% remaining cases, the masked tokens are left as is.

Pretraining

The model was trained on a NVIDIA GeForce RTX 4090 using 16-bit precision for 20 million steps with a batch size of 24. The sequence length was limited 512. The optimizer used is Adam with a learning rate of 5e-5, \(\beta*{1} = 0.9\) and \(\beta*{2} = 0.999\), a weight decay of 0.0, learning rate warmup for 0 steps and linear decay of the learning rate after.

<!-- ## Evaluation results When fine-tuned on downstream tasks, this model achieves the following results: Glue test results: | Task | MNLI-(m/mm) | QQP | QNLI | SST-2 | CoLA | STS-B | MRPC | RTE | Average | | :---: | :---------: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :-----: | | | 84.6/83.4 | 71.2 | 90.5 | 93.5 | 52.1 | 85.8 | 88.9 | 66.4 | 79.6 | --> |

Framework versions

• Transformers 4.27.0.dev0
• Pytorch 1.13.1+cu117
• Datasets 2.9.0
• Tokenizers 0.13.2

<!-- ### BibTeX entry and citation info --> <!-- ```bibtex @article{ } ``` -->