run_tf_ner.py 10.9 KB
Newer Older
1
# coding=utf-8
Julien Plu's avatar
Julien Plu committed
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# Copyright 2018 The HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
""" Fine-tuning the library models for named entity recognition."""


import logging
Aymeric Augustin's avatar
Aymeric Augustin committed
19
import os
Julien Plu's avatar
Julien Plu committed
20
from dataclasses import dataclass, field
21
from importlib import import_module
Julien Plu's avatar
Julien Plu committed
22
from typing import Dict, List, Optional, Tuple
Aymeric Augustin's avatar
Aymeric Augustin committed
23

24
import numpy as np
Julien Plu's avatar
Julien Plu committed
25
from seqeval.metrics import classification_report, f1_score, precision_score, recall_score
26

Aymeric Augustin's avatar
Aymeric Augustin committed
27
from transformers import (
28
29
    AutoConfig,
    AutoTokenizer,
Julien Plu's avatar
Julien Plu committed
30
31
    EvalPrediction,
    HfArgumentParser,
32
    TFAutoModelForTokenClassification,
Julien Plu's avatar
Julien Plu committed
33
34
    TFTrainer,
    TFTrainingArguments,
Aymeric Augustin's avatar
Aymeric Augustin committed
35
)
36
from transformers.utils import logging as hf_logging
37
from utils_ner import Split, TFTokenClassificationDataset, TokenClassificationTask
38
39


40
41
42
43
44
hf_logging.set_verbosity_info()
hf_logging.enable_default_handler()
hf_logging.enable_explicit_format()


Julien Plu's avatar
Julien Plu committed
45
logger = logging.getLogger(__name__)
46
47


Julien Plu's avatar
Julien Plu committed
48
49
50
51
52
@dataclass
class ModelArguments:
    """
    Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
    """
53

Julien Plu's avatar
Julien Plu committed
54
55
    model_name_or_path: str = field(
        metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}
56
    )
Julien Plu's avatar
Julien Plu committed
57
58
    config_name: Optional[str] = field(
        default=None, metadata={"help": "Pretrained config name or path if not the same as model_name"}
59
    )
60
61
62
    task_type: Optional[str] = field(
        default="NER", metadata={"help": "Task type to fine tune in training (e.g. NER, POS, etc)"}
    )
Julien Plu's avatar
Julien Plu committed
63
64
65
66
67
68
69
    tokenizer_name: Optional[str] = field(
        default=None, metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}
    )
    use_fast: bool = field(default=False, metadata={"help": "Set this flag to use fast tokenization."})
    # If you want to tweak more attributes on your tokenizer, you should do it in a distinct script,
    # or just modify its tokenizer_config.json.
    cache_dir: Optional[str] = field(
70
71
        default=None,
        metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"},
72
    )
73
74


Julien Plu's avatar
Julien Plu committed
75
76
77
78
79
@dataclass
class DataTrainingArguments:
    """
    Arguments pertaining to what data we are going to input our model for training and eval.
    """
80

Julien Plu's avatar
Julien Plu committed
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
    data_dir: str = field(
        metadata={"help": "The input data dir. Should contain the .txt files for a CoNLL-2003-formatted task."}
    )
    labels: Optional[str] = field(
        metadata={"help": "Path to a file containing all labels. If not specified, CoNLL-2003 labels are used."}
    )
    max_seq_length: int = field(
        default=128,
        metadata={
            "help": "The maximum total input sequence length after tokenization. Sequences longer "
            "than this will be truncated, sequences shorter will be padded."
        },
    )
    overwrite_cache: bool = field(
        default=False, metadata={"help": "Overwrite the cached training and evaluation sets"}
    )
97
98


Julien Plu's avatar
Julien Plu committed
99
100
101
102
103
104
def main():
    # See all possible arguments in src/transformers/training_args.py
    # or by passing the --help flag to this script.
    # We now keep distinct sets of args, for a cleaner separation of concerns.
    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TFTrainingArguments))
    model_args, data_args, training_args = parser.parse_args_into_dataclasses()
105

106
    if (
Julien Plu's avatar
Julien Plu committed
107
108
109
110
        os.path.exists(training_args.output_dir)
        and os.listdir(training_args.output_dir)
        and training_args.do_train
        and not training_args.overwrite_output_dir
111
    ):
112
        raise ValueError(
Julien Plu's avatar
Julien Plu committed
113
            f"Output directory ({training_args.output_dir}) already exists and is not empty. Use --overwrite_output_dir to overcome."
114
        )
115

116
117
118
119
120
121
122
123
124
125
126
    module = import_module("tasks")

    try:
        token_classification_task_clazz = getattr(module, model_args.task_type)
        token_classification_task: TokenClassificationTask = token_classification_task_clazz()
    except AttributeError:
        raise ValueError(
            f"Task {model_args.task_type} needs to be defined as a TokenClassificationTask subclass in {module}. "
            f"Available tasks classes are: {TokenClassificationTask.__subclasses__()}"
        )

Julien Plu's avatar
Julien Plu committed
127
128
129
130
131
    # Setup logging
    logging.basicConfig(
        format="%(asctime)s - %(levelname)s - %(name)s -   %(message)s",
        datefmt="%m/%d/%Y %H:%M:%S",
        level=logging.INFO,
132
    )
Julien Plu's avatar
Julien Plu committed
133
    logger.info(
134
135
136
        "n_replicas: %s, distributed training: %s, 16-bits training: %s",
        training_args.n_replicas,
        bool(training_args.n_replicas > 1),
Julien Plu's avatar
Julien Plu committed
137
138
139
        training_args.fp16,
    )
    logger.info("Training/evaluation parameters %s", training_args)
140

Julien Plu's avatar
Julien Plu committed
141
    # Prepare Token Classification task
142
    labels = token_classification_task.get_labels(data_args.labels)
Julien Plu's avatar
Julien Plu committed
143
    label_map: Dict[int, str] = {i: label for i, label in enumerate(labels)}
Julien Plu's avatar
Julien Plu committed
144
    num_labels = len(labels)
Julien Plu's avatar
Julien Plu committed
145
146
147
148
149
150
151

    # Load pretrained model and tokenizer
    #
    # Distributed training:
    # The .from_pretrained methods guarantee that only one local process can concurrently
    # download model & vocab.

152
    config = AutoConfig.from_pretrained(
Julien Plu's avatar
Julien Plu committed
153
        model_args.config_name if model_args.config_name else model_args.model_name_or_path,
154
        num_labels=num_labels,
Julien Plu's avatar
Julien Plu committed
155
156
157
158
159
160
161
162
        id2label=label_map,
        label2id={label: i for i, label in enumerate(labels)},
        cache_dir=model_args.cache_dir,
    )
    tokenizer = AutoTokenizer.from_pretrained(
        model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path,
        cache_dir=model_args.cache_dir,
        use_fast=model_args.use_fast,
163
    )
164

Julien Plu's avatar
Julien Plu committed
165
166
167
168
169
170
    with training_args.strategy.scope():
        model = TFAutoModelForTokenClassification.from_pretrained(
            model_args.model_name_or_path,
            from_pt=bool(".bin" in model_args.model_name_or_path),
            config=config,
            cache_dir=model_args.cache_dir,
171
        )
172

Julien Plu's avatar
Julien Plu committed
173
174
    # Get datasets
    train_dataset = (
175
176
        TFTokenClassificationDataset(
            token_classification_task=token_classification_task,
Julien Plu's avatar
Julien Plu committed
177
178
179
180
181
182
183
            data_dir=data_args.data_dir,
            tokenizer=tokenizer,
            labels=labels,
            model_type=config.model_type,
            max_seq_length=data_args.max_seq_length,
            overwrite_cache=data_args.overwrite_cache,
            mode=Split.train,
184
        )
Julien Plu's avatar
Julien Plu committed
185
186
187
188
        if training_args.do_train
        else None
    )
    eval_dataset = (
189
190
        TFTokenClassificationDataset(
            token_classification_task=token_classification_task,
Julien Plu's avatar
Julien Plu committed
191
192
193
194
195
196
197
            data_dir=data_args.data_dir,
            tokenizer=tokenizer,
            labels=labels,
            model_type=config.model_type,
            max_seq_length=data_args.max_seq_length,
            overwrite_cache=data_args.overwrite_cache,
            mode=Split.dev,
198
        )
Julien Plu's avatar
Julien Plu committed
199
200
201
        if training_args.do_eval
        else None
    )
202

Julien Plu's avatar
Julien Plu committed
203
204
205
206
207
208
209
210
    def align_predictions(predictions: np.ndarray, label_ids: np.ndarray) -> Tuple[List[int], List[int]]:
        preds = np.argmax(predictions, axis=2)
        batch_size, seq_len = preds.shape
        out_label_list = [[] for _ in range(batch_size)]
        preds_list = [[] for _ in range(batch_size)]

        for i in range(batch_size):
            for j in range(seq_len):
211
                if label_ids[i, j] != -100:
Julien Plu's avatar
Julien Plu committed
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
                    out_label_list[i].append(label_map[label_ids[i][j]])
                    preds_list[i].append(label_map[preds[i][j]])

        return preds_list, out_label_list

    def compute_metrics(p: EvalPrediction) -> Dict:
        preds_list, out_label_list = align_predictions(p.predictions, p.label_ids)

        return {
            "precision": precision_score(out_label_list, preds_list),
            "recall": recall_score(out_label_list, preds_list),
            "f1": f1_score(out_label_list, preds_list),
        }

    # Initialize our Trainer
    trainer = TFTrainer(
        model=model,
        args=training_args,
        train_dataset=train_dataset.get_dataset() if train_dataset else None,
        eval_dataset=eval_dataset.get_dataset() if eval_dataset else None,
        compute_metrics=compute_metrics,
    )
234

Julien Plu's avatar
Julien Plu committed
235
236
237
238
239
    # Training
    if training_args.do_train:
        trainer.train()
        trainer.save_model()
        tokenizer.save_pretrained(training_args.output_dir)
240
241

    # Evaluation
Julien Plu's avatar
Julien Plu committed
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
    results = {}
    if training_args.do_eval:
        logger.info("*** Evaluate ***")

        result = trainer.evaluate()
        output_eval_file = os.path.join(training_args.output_dir, "eval_results.txt")

        with open(output_eval_file, "w") as writer:
            logger.info("***** Eval results *****")

            for key, value in result.items():
                logger.info("  %s = %s", key, value)
                writer.write("%s = %s\n" % (key, value))

            results.update(result)

    # Predict
    if training_args.do_predict:
260
261
        test_dataset = TFTokenClassificationDataset(
            token_classification_task=token_classification_task,
Julien Plu's avatar
Julien Plu committed
262
263
264
265
266
267
268
            data_dir=data_args.data_dir,
            tokenizer=tokenizer,
            labels=labels,
            model_type=config.model_type,
            max_seq_length=data_args.max_seq_length,
            overwrite_cache=data_args.overwrite_cache,
            mode=Split.test,
269
        )
270

Julien Plu's avatar
Julien Plu committed
271
272
273
274
275
        predictions, label_ids, metrics = trainer.predict(test_dataset.get_dataset())
        preds_list, labels_list = align_predictions(predictions, label_ids)
        report = classification_report(labels_list, preds_list)

        logger.info("\n%s", report)
276

Julien Plu's avatar
Julien Plu committed
277
        output_test_results_file = os.path.join(training_args.output_dir, "test_results.txt")
278

Julien Plu's avatar
Julien Plu committed
279
280
        with open(output_test_results_file, "w") as writer:
            writer.write("%s\n" % report)
281

Julien Plu's avatar
Julien Plu committed
282
283
284
285
286
        # Save predictions
        output_test_predictions_file = os.path.join(training_args.output_dir, "test_predictions.txt")

        with open(output_test_predictions_file, "w") as writer:
            with open(os.path.join(data_args.data_dir, "test.txt"), "r") as f:
287
288
289
290
291
292
                example_id = 0

                for line in f:
                    if line.startswith("-DOCSTART-") or line == "" or line == "\n":
                        writer.write(line)

Julien Plu's avatar
Julien Plu committed
293
                        if not preds_list[example_id]:
294
                            example_id += 1
Julien Plu's avatar
Julien Plu committed
295
296
297
                    elif preds_list[example_id]:
                        output_line = line.split()[0] + " " + preds_list[example_id].pop(0) + "\n"

298
299
                        writer.write(output_line)
                    else:
Julien Plu's avatar
Julien Plu committed
300
301
302
                        logger.warning("Maximum sequence length exceeded: No prediction for '%s'.", line.split()[0])

    return results
303
304
305


if __name__ == "__main__":
Julien Plu's avatar
Julien Plu committed
306
    main()