| 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 = 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") |
| |
| 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") |
| |
|
|
| def test_dataloader(self): |
| return self.prepare_dataloader("test") |
| |
|
|
| def val_dataloader(self): |
| return self.prepare_dataloader("val") |
| |
|
|
|
|
| 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 |
| |
| |
| |
| |
| |
| |
| else: |
| preds = outputs['logits'].tolist() |
| gold = batch[2].tolist() |
| ret['preds'] = preds |
| ret['gold'] = gold |
| |
| |
| |
|
|
| 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) |
|
|
