File size: 3,019 Bytes
7023796
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
"""Fine-tune DistilRoBERTa for script / payload intent classification.

Usage: python src/train.py --data data --out outputs/model --epochs 3
"""
import argparse
import json
import os
import sys

import numpy as np
from datasets import load_dataset
from sklearn.metrics import accuracy_score, precision_recall_fscore_support
from transformers import (AutoModelForSequenceClassification, AutoTokenizer,
                          DataCollatorWithPadding, Trainer, TrainingArguments)

sys.path.insert(0, os.path.dirname(__file__))
from templates import LABELS  # noqa: E402


def compute_metrics(p):
    preds = np.argmax(p.predictions, axis=-1)
    _, _, f1_macro, _ = precision_recall_fscore_support(p.label_ids, preds, average="macro", zero_division=0)
    return {"accuracy": accuracy_score(p.label_ids, preds), "f1_macro": f1_macro}


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--data", default="data")
    ap.add_argument("--base", default="distilroberta-base")
    ap.add_argument("--out", default="outputs/model")
    ap.add_argument("--epochs", type=float, default=3)
    ap.add_argument("--lr", type=float, default=5e-5)
    ap.add_argument("--bs", type=int, default=32)
    ap.add_argument("--max-len", type=int, default=128)
    ap.add_argument("--seed", type=int, default=42)
    args = ap.parse_args()

    ds = load_dataset("json", data_files={s: f"{args.data}/{s}.jsonl" for s in ("train", "validation", "test")})
    tok = AutoTokenizer.from_pretrained(args.base)

    def enc(b):
        out = tok(b["text"], truncation=True, max_length=args.max_len)
        out["labels"] = b["label_id"]
        return out

    ds_tok = ds.map(enc, batched=True, remove_columns=ds["train"].column_names)

    id2label = dict(enumerate(LABELS))
    model = AutoModelForSequenceClassification.from_pretrained(
        args.base, num_labels=len(LABELS), id2label=id2label, label2id={v: k for k, v in id2label.items()})

    targs = TrainingArguments(
        output_dir=args.out + "_ckpt",
        num_train_epochs=args.epochs,
        learning_rate=args.lr,
        per_device_train_batch_size=args.bs,
        per_device_eval_batch_size=64,
        warmup_steps=int(0.06 * args.epochs * len(ds_tok["train"]) / args.bs),
        weight_decay=0.01,
        eval_strategy="epoch",
        save_strategy="epoch",
        save_total_limit=1,
        load_best_model_at_end=True,
        metric_for_best_model="f1_macro",
        logging_steps=25,
        report_to=[],
        seed=args.seed,
        dataloader_num_workers=0,
    )
    trainer = Trainer(model=model, args=targs, train_dataset=ds_tok["train"], eval_dataset=ds_tok["validation"],
                      data_collator=DataCollatorWithPadding(tok), compute_metrics=compute_metrics)
    trainer.train()
    trainer.save_model(args.out)
    tok.save_pretrained(args.out)
    with open(os.path.join(args.out, "training_log.json"), "w") as f:
        json.dump(trainer.state.log_history, f, indent=1)


if __name__ == "__main__":
    main()