Add scripts used for trainin/evaluating multilingual models

politeness_regressor.py

@@ -0,0 +1,273 @@
+from argparse import ArgumentParser
+from typing import List, Dict
+
+import numpy as np
+import pytorch_lightning as pl
+import sklearn.metrics
+import sklearn.model_selection
+import torch
+import torch.optim
+import torch.utils.data
+import transformers
+import pandas as pd
+import random
+import sklearn.metrics
+
+try:
+    from polyglot.text import Text
+except:
+    print("polyglot not installed. Cannot use --strategy_words")
+
+class MyDataModule(pl.LightningDataModule):
+    def __init__(self, train_file, test_file, binary, tokenizer, max_length, batch_size, strategy_words_replacement_negate=False, strategy_words=None, random_masking_ratio=None):
+        super().__init__()
+        self.train_file = train_file
+        self.test_file = test_file
+        self.binary = binary
+        self.max_length = max_length
+        self.batch_size = batch_size
+        self.tokenizer = tokenizer
+
+        if strategy_words:
+            self.strategy_words = pd.read_csv(strategy_words)
+            self.strategy_words = set(list(self.strategy_words.values[:, 1:].reshape(-1)))
+        else:
+            self.strategy_words = None
+        self.strategy_words_replacement_negate = strategy_words_replacement_negate
+        self.random_masking_ratio = random_masking_ratio
+
+    @staticmethod   
+    def read_file(file_name, text_only=False):
+        if file_name.split(".")[-1] == "csv":
+            df = pd.read_csv(file_name)
+            data = [(a, b) for a, b in zip(list(df['sentence']), df['score'])]
+            if text_only:
+                data = [t[0] for t in data]
+        else:
+            data = open(file_name).read().strip().split('\n')
+        return data
+
+    def setup(self, stage=None):
+        if self.train_file:
+            self.train_data = MyDataModule.read_file(self.train_file)
+            self.train_data, self.val_data = sklearn.model_selection.train_test_split(self.train_data, shuffle=False, test_size=0.2)
+        if self.test_file:
+            self.test_data = MyDataModule.read_file(self.test_file)
+
+    def prepare_dataloader(self, mode):
+        if mode == "train":
+            data = self.train_data
+        elif mode == "val":
+            data = self.val_data
+        else:
+            data = self.test_data
+
+        # tokenized = self.tokenizer([t[0] for t in data], padding="max_length", truncation=True, max_length=self.max_length, return_tensors="pt")
+        tokenized = MyDataModule.tokenize([t[0] for t in data], self.tokenizer, self.max_length, self.strategy_words_replacement_negate, self.strategy_words, self.random_masking_ratio)
+        if self.binary:
+            labels = torch.tensor([t[1] > 0 for t in data], dtype=int)
+        else:
+            labels = torch.tensor([t[1] for t in data])
+
+        if mode == "train":
+            weights = torch.zeros_like(labels)
+            weights[labels == 0] = labels.shape[0] - labels.sum()
+            weights[labels == 1] = labels.sum()
+            return torch.utils.data.DataLoader(torch.utils.data.TensorDataset(tokenized['input_ids'], tokenized['attention_mask'], labels), batch_size=self.batch_size, sampler=torch.utils.data.WeightedRandomSampler(1 / weights, len(weights), replacement=True))
+        else:
+            return torch.utils.data.DataLoader(torch.utils.data.TensorDataset(tokenized['input_ids'], tokenized['attention_mask'], labels), batch_size=self.batch_size)
+
+    @staticmethod
+    def tokenize(data: List[str], tokenizer, max_length, strategy_words_replacement_negate, strategy_words, random_masking_ratio):
+        if strategy_words is not None or random_masking_ratio is not None:
+            tokenized_data = []
+            for sentence in data:
+                words = Text(sentence).words
+                words = [t.lower() for t in words]
+                if strategy_words:
+                    words = [t if ((t in strategy_words) != strategy_words_replacement_negate) else tokenizer.mask_token for t in words]
+                elif random_masking_ratio:
+                    words = [t if random.random() <= random_masking_ratio else tokenizer.mask_token for t in words]
+                tokenized_data.append(' '.join(words))
+            out = tokenizer(tokenized_data, padding="max_length", truncation=True, max_length=max_length, return_tensors="pt")
+            # out['attention_mask'] = torch.tensor(out['input_ids'] != tokenizer.pad_token_id, dtype=int)
+            return out
+        else:
+            return tokenizer(data, padding="max_length", truncation=True, max_length=max_length, return_tensors="pt")
+
+    def train_dataloader(self):
+        return self.prepare_dataloader("train")
+        # return torch.utils.data.DataLoader(MyDataModule.CustomDataset1(self.tokenizer, self.train_data, self.max_length), batch_size=self.batch_size)
+
+    def test_dataloader(self):
+        return self.prepare_dataloader("test")
+        # return torch.utils.data.DataLoader(MyDataModule.CustomDataset1(self.tokenizer, self.test_data, self.max_length), batch_size=self.batch_size)
+
+    def val_dataloader(self):
+        return self.prepare_dataloader("val")
+        # return torch.utils.data.DataLoader(MyDataModule.CustomDataset1(self.tokenizer, self.val_data, self.max_length), batch_size=self.batch_size)
+
+
+class RegressionModel(pl.LightningModule):
+    def __init__(self, pretrained_model, binary, learning_rate, num_warmup_steps, tokenizer):
+        super(RegressionModel, self).__init__()
+        self.save_hyperparameters()
+        self.pretrained_model = pretrained_model
+        self.binary = binary
+        self.learning_rate = learning_rate
+        self.num_warmup_steps = num_warmup_steps
+        self.tokenizer = tokenizer
+        self.model = transformers.AutoModelForSequenceClassification.from_pretrained(self.pretrained_model, num_labels=2 if self.binary else 1)
+
+    def forward(self, **kwargs):
+        return self.model(**kwargs)
+
+    def training_step(self, batch, batch_idx):
+        outputs = self.forward(input_ids=batch[0], attention_mask=batch[1], labels=batch[2])
+        loss = outputs['loss']
+        ret = {"loss": loss}
+        if self.binary:
+            acc = torch.tensor(batch[2] == torch.argmax(outputs['logits']), dtype=float).mean().item()
+            ret["acc"] = acc
+        else:
+            rmse = (torch.mean((batch[2] - outputs['logits'])**2)**0.5).item()
+            ret["rmse"] = rmse
+
+        return {"loss": loss, "log": ret}
+
+    def configure_optimizers(self):
+        optimizer = torch.optim.AdamW(self.parameters(), lr=self.learning_rate)
+        scheduler = transformers.get_linear_schedule_with_warmup(optimizer, self.num_warmup_steps, len(self.trainer.datamodule.train_dataloader()) // self.trainer.accumulate_grad_batches)
+        return [optimizer], [scheduler]
+
+    def test_step(self, batch, batch_idx):
+        return self.validation_step(batch, batch_idx, mode="test")
+
+    def validation_step(self, batch, batch_idx, mode="val"):
+        outputs = self.forward(input_ids=batch[0], attention_mask=batch[1], labels=batch[2])
+        loss = outputs['loss']
+        self.log("{}_loss".format(mode), loss, prog_bar=True)
+
+        ret = {"loss": loss}
+        if self.binary:
+            preds = torch.argmax(outputs['logits'], axis=1).tolist()
+            gold = batch[2].tolist()
+            ret["preds"] = preds
+            ret["gold"] = gold
+            # f1 = sklearn.metrics.f1_score(gold, preds)
+            # acc = sklearn.metrics.accuracy_score(gold, preds)
+            # ret["acc"] = acc
+            # ret["f1"] = f1
+            # self.log("{}_acc".format(mode), acc, prog_bar=True)
+            # self.log("{}_f1".format(mode), f1, prog_bar=True)
+        else:
+            preds = outputs['logits'].tolist()
+            gold = batch[2].tolist()
+            ret['preds'] = preds
+            ret['gold'] = gold
+            # rmse = (torch.mean((batch[2] - outputs['logits'])**2)**0.5).item()
+            # self.log("{}_rmse".format(mode), rmse, prog_bar=True)
+            # ret["rmse"] = rmse
+
+        return {"loss": loss, "log": ret}
+
+    def validation_epoch_end(self, outputs, mode="val"):
+        gold = []
+        preds = []
+        for batch in outputs:
+            gold.extend(batch['log']['gold'])
+            preds.extend(batch['log']['preds'])
+        if self.binary:
+            f1 = sklearn.metrics.f1_score(gold, preds)
+            acc = sklearn.metrics.accuracy_score(gold, preds)
+            self.log("{}_acc".format(mode), acc, prog_bar=True)
+            self.log("{}_f1".format(mode), f1, prog_bar=True)
+        else:
+            rmse = (torch.mean((torch.tensor(gold) - torch.tensor(preds))**2)**0.5).item()
+            self.log("{}_rmse".format(mode), rmse, prog_bar=True)
+
+    def test_epoch_end(self, outputs):
+        return self.validation_epoch_end(outputs, mode="test")
+
+    def predict_step(self, batch, batch_idx):
+        preds = self.forward(input_ids=batch[0], attention_mask=batch[1])
+        if self.binary:
+            ret = preds['logits'].tolist()
+        else:
+            ret = preds['logits'].view(-1).tolist()
+        return ret
+
+    @staticmethod
+    def add_model_specific_args(parent_parser):
+        parser = parent_parser.add_argument_group("RegressionModel")
+        parser.add_argument('--pretrained_model', type=str)
+        parser.add_argument('--learning_rate', type=float, default="5e-6")
+        parser.add_argument('--num_warmup_steps', type=float, default="0")
+        return parent_parser
+
+
+if __name__ == "__main__":
+    parser = ArgumentParser()
+    parser.add_argument("--train", action="store_true")
+    parser.add_argument("--test", action="store_true")
+    parser.add_argument("--load_model", type=str)
+    parser.add_argument("--train_file", type=str)
+    parser.add_argument("--test_file", type=str)
+    parser.add_argument("--binary", action="store_true")
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--batch_size", type=int, default=64)
+    parser.add_argument("--max_length", type=int, default=128)
+    parser.add_argument("--model_save_location", type=str)
+    parser.add_argument("--preds_save_location", type=str)
+    parser.add_argument("--preds_save_logits", action="store_true")
+    parser.add_argument("--strategy_words", type=str)
+    parser.add_argument("--strategy_words_replacement_negate", action="store_true")
+    parser.add_argument("--random_masking_ratio", type=float)
+    parser = RegressionModel.add_model_specific_args(parser)
+    parser = pl.Trainer.add_argparse_args(parser)
+    args = parser.parse_args()
+    print(args)
+
+    pl.utilities.seed.seed_everything(seed=args.seed)
+    if args.load_model:
+        model = RegressionModel.load_from_checkpoint(args.load_model)
+        tokenizer = model.tokenizer
+    else:
+        tokenizer = transformers.AutoTokenizer.from_pretrained(args.pretrained_model)
+        model = RegressionModel(pretrained_model=args.pretrained_model, binary=args.binary, learning_rate=args.learning_rate, num_warmup_steps=args.num_warmup_steps, tokenizer=tokenizer)
+    trainer = pl.Trainer.from_argparse_args(args)
+
+    dataset = MyDataModule(train_file=args.train_file, test_file=args.test_file, binary=model.binary, max_length=args.max_length, batch_size=args.batch_size, tokenizer=tokenizer, strategy_words_replacement_negate=args.strategy_words_replacement_negate, strategy_words=args.strategy_words, random_masking_ratio=args.random_masking_ratio)
+    dataset.setup()
+
+    if args.train:
+        trainer.fit(model, dataset)
+
+    if args.test:
+        trainer.test(model, dataset.test_dataloader())
+
+    if args.preds_save_location:
+        data = MyDataModule.read_file(args.test_file, True)
+        strategy_words = None
+        if args.strategy_words:
+            strategy_words = pd.read_csv(args.strategy_words)
+            strategy_words = set(list(args.strategy_words.values[:, 1:].reshape(-1)))
+        tokenized = MyDataModule.tokenize(data, tokenizer, args.max_length, args.strategy_words_replacement_negate, strategy_words, args.random_masking_ratio)
+        input_data = torch.utils.data.DataLoader(torch.utils.data.TensorDataset(tokenized['input_ids'], tokenized['attention_mask']), batch_size=args.batch_size)
+        preds = trainer.predict(model, input_data, return_predictions=True)
+        preds = [t for y in preds for t in y]
+        preds = torch.tensor(preds)
+        if model.binary:
+            if args.preds_save_logits:
+                preds = torch.softmax(preds, axis=1)[:, 1].tolist()
+            else:
+                preds = preds.argmax(axis=1).tolist()
+        else:
+            preds = preds.view(-1).tolist()
+        preds = [str(t) for t in preds]
+
+        with open(args.preds_save_location, 'w') as f:
+            f.write('\n'.join(preds) + '\n')
+
+    if args.model_save_location:
+        trainer.save_checkpoint(args.model_save_location, weights_only=True)

requirements.txt

@@ -0,0 +1,5 @@
+numpy
+pandas
+torch
+pytorch-lightning
+sklearn