Upload folder using huggingface_hub

README.md

@@ -0,0 +1,61 @@
+# NER Fine-Tuning
+
+We use Flair for fine-tuning NER models on
+[HIPE-2022](https://github.com/hipe-eval/HIPE-2022-data) datasets from
+[HIPE-2022 Shared Task](https://hipe-eval.github.io/HIPE-2022/).
+
+All models are fine-tuned on A10 (24GB) and A100 (40GB) instances from
+[Lambda Cloud](https://lambdalabs.com/service/gpu-cloud) using Flair:
+
+```bash
+$ git clone https://github.com/flairNLP/flair.git
+$ cd flair && git checkout 419f13a05d6b36b2a42dd73a551dc3ba679f820c
+$ pip3 install -e .
+$ cd ..
+```
+
+Clone this repo for fine-tuning NER models:
+
+```bash
+$ git clone https://github.com/stefan-it/hmTEAMS.git
+$ cd hmTEAMS/bench
+```
+
+Authorize via Hugging Face CLI (needed because hmTEAMS is currently only available after approval):
+
+```bash
+# Use access token from https://huggingface.co/settings/tokens
+$ huggingface-cli login login
+```
+
+We use a config-driven hyper-parameter search. The script [`flair-fine-tuner.py`](flair-fine-tuner.py) can be used to
+fine-tune NER models from our Model Zoo.
+
+# Benchmark
+
+We test our pretrained language models on various datasets from HIPE-2020, HIPE-2022 and Europeana. The following table
+shows an overview of used datasets.
+
+| Language | Datasets
+|----------|----------------------------------------------------|
+| English  | [AjMC] - [TopRes19th]                              |
+| German   | [AjMC] - [NewsEye]                                 |
+| French   | [AjMC] - [ICDAR-Europeana] - [LeTemps] - [NewsEye] |
+| Finnish  | [NewsEye]                                          |
+| Swedish  | [NewsEye]                                          |
+| Dutch    | [ICDAR-Europeana]                                  |
+
+[AjMC]: https://github.com/hipe-eval/HIPE-2022-data/blob/main/documentation/README-ajmc.md
+[NewsEye]: https://github.com/hipe-eval/HIPE-2022-data/blob/main/documentation/README-newseye.md
+[TopRes19th]: https://github.com/hipe-eval/HIPE-2022-data/blob/main/documentation/README-topres19th.md
+[ICDAR-Europeana]: https://github.com/stefan-it/historic-domain-adaptation-icdar
+[LeTemps]: https://github.com/hipe-eval/HIPE-2022-data/blob/main/documentation/README-letemps.md
+
+# Results
+
+We report averaged F1-score over 5 runs with different seeds on development set:
+
+| Model                                                                     | English AjMC | German AjMC  | French AjMC  | German NewsEye | French NewsEye | Finnish NewsEye | Swedish NewsEye | Dutch ICDAR  | French ICDAR | French LeTemps | English TopRes19th | Avg.      |
+|---------------------------------------------------------------------------|--------------|--------------|--------------|----------------|----------------|-----------------|-----------------|--------------|--------------|----------------|--------------------|-----------|
+| hmBERT (32k) [Schweter et al.](https://ceur-ws.org/Vol-3180/paper-87.pdf) | 85.36 ± 0.94 | 89.08 ± 0.09 | 85.10 ± 0.60 |  39.65 ± 1.01  |  81.47 ± 0.36  | 77.28 ± 0.37    | 82.85 ± 0.83    | 82.11 ± 0.61 | 77.21 ± 0.16 | 65.73 ± 0.56   |    80.94 ± 0.86    |   76.98   |
+| hmTEAMS (Ours)                                                            | 86.41 ± 0.36 | 88.64 ± 0.42 | 85.41 ± 0.67 |  41.51 ± 2.82  |  83.20 ± 0.79  | 79.27 ± 1.88    | 82.78 ± 0.60    | 88.21 ± 0.39 | 78.03 ± 0.39 | 66.71 ± 0.46   |    81.36 ± 0.59    | **78.32** |

auto-train/hmbench-hipe2020/de-hmteams/teams-base-historic-multilingual-discriminator-bs8-wsFalse-e10-lr3e-05-poolingfirst-layers-1-crfFalse-1/training.log

@@ -0,0 +1,71 @@
+2023-09-02 00:42:11,828 ----------------------------------------------------------------------------------------------------
+2023-09-02 00:42:11,829 Model: "SequenceTagger(
+  (embeddings): TransformerWordEmbeddings(
+    (model): ElectraModel(
+      (embeddings): ElectraEmbeddings(
+        (word_embeddings): Embedding(32001, 768)
+        (position_embeddings): Embedding(512, 768)
+        (token_type_embeddings): Embedding(2, 768)
+        (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
+        (dropout): Dropout(p=0.1, inplace=False)
+      )
+      (encoder): ElectraEncoder(
+        (layer): ModuleList(
+          (0-11): 12 x ElectraLayer(
+            (attention): ElectraAttention(
+              (self): ElectraSelfAttention(
+                (query): Linear(in_features=768, out_features=768, bias=True)
+                (key): Linear(in_features=768, out_features=768, bias=True)
+                (value): Linear(in_features=768, out_features=768, bias=True)
+                (dropout): Dropout(p=0.1, inplace=False)
+              )
+              (output): ElectraSelfOutput(
+                (dense): Linear(in_features=768, out_features=768, bias=True)
+                (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
+                (dropout): Dropout(p=0.1, inplace=False)
+              )
+            )
+            (intermediate): ElectraIntermediate(
+              (dense): Linear(in_features=768, out_features=3072, bias=True)
+              (intermediate_act_fn): GELUActivation()
+            )
+            (output): ElectraOutput(
+              (dense): Linear(in_features=3072, out_features=768, bias=True)
+              (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
+              (dropout): Dropout(p=0.1, inplace=False)
+            )
+          )
+        )
+      )
+    )
+  )
+  (locked_dropout): LockedDropout(p=0.5)
+  (linear): Linear(in_features=768, out_features=21, bias=True)
+  (loss_function): CrossEntropyLoss()
+)"
+2023-09-02 00:42:11,829 ----------------------------------------------------------------------------------------------------
+2023-09-02 00:42:11,829 MultiCorpus: 3575 train + 1235 dev + 1266 test sentences
+ - NER_HIPE_2022 Corpus: 3575 train + 1235 dev + 1266 test sentences - /home/stefan/.flair/datasets/ner_hipe_2022/v2.1/hipe2020/de/with_doc_seperator
+2023-09-02 00:42:11,829 ----------------------------------------------------------------------------------------------------
+2023-09-02 00:42:11,829 Train:  3575 sentences
+2023-09-02 00:42:11,829         (train_with_dev=False, train_with_test=False)
+2023-09-02 00:42:11,829 ----------------------------------------------------------------------------------------------------
+2023-09-02 00:42:11,829 Training Params:
+2023-09-02 00:42:11,829  - learning_rate: "3e-05" 
+2023-09-02 00:42:11,829  - mini_batch_size: "8"
+2023-09-02 00:42:11,829  - max_epochs: "10"
+2023-09-02 00:42:11,829  - shuffle: "True"
+2023-09-02 00:42:11,829 ----------------------------------------------------------------------------------------------------
+2023-09-02 00:42:11,829 Plugins:
+2023-09-02 00:42:11,829  - LinearScheduler | warmup_fraction: '0.1'
+2023-09-02 00:42:11,829 ----------------------------------------------------------------------------------------------------
+2023-09-02 00:42:11,829 Final evaluation on model from best epoch (best-model.pt)
+2023-09-02 00:42:11,829  - metric: "('micro avg', 'f1-score')"
+2023-09-02 00:42:11,829 ----------------------------------------------------------------------------------------------------
+2023-09-02 00:42:11,829 Computation:
+2023-09-02 00:42:11,829  - compute on device: cuda:0
+2023-09-02 00:42:11,829  - embedding storage: none
+2023-09-02 00:42:11,829 ----------------------------------------------------------------------------------------------------
+2023-09-02 00:42:11,829 Model training base path: "hmbench-hipe2020/de-hmteams/teams-base-historic-multilingual-discriminator-bs8-wsFalse-e10-lr3e-05-poolingfirst-layers-1-crfFalse-1"
+2023-09-02 00:42:11,829 ----------------------------------------------------------------------------------------------------
+2023-09-02 00:42:11,829 ----------------------------------------------------------------------------------------------------

configs/ajmc/de/hmbert.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "dbmdz/bert-base-historic-multilingual-cased",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["ajmc/de"],
+    "cuda": "0"
+}

configs/ajmc/de/hmteams.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "hmteams/teams-base-historic-multilingual-discriminator",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["ajmc/de"],
+    "cuda": "0"
+}

configs/ajmc/en/hmbert.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "dbmdz/bert-base-historic-multilingual-cased",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["ajmc/en"],
+    "cuda": "0"
+}

configs/ajmc/en/hmteams.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "hmteams/teams-base-historic-multilingual-discriminator",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["ajmc/en"],
+    "cuda": "0"
+}

configs/ajmc/fr/hmbert.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "dbmdz/bert-base-historic-multilingual-cased",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["ajmc/fr"],
+    "cuda": "0"
+}

configs/ajmc/fr/hmteams.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "hmteams/teams-base-historic-multilingual-discriminator",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["ajmc/fr"],
+    "cuda": "0"
+}

configs/ajmc/multi/hmbert.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "dbmdz/bert-base-historic-multilingual-cased",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["ajmc/de", "ajmc/en", "ajmc/fr"],
+    "cuda": "0"
+}

configs/ajmc/multi/hmteams.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "hmteams/teams-base-historic-multilingual-discriminator",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["ajmc/de", "ajmc/en", "ajmc/fr"],
+    "cuda": "0"
+}

configs/hipe2020/de/hmbert.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [8, 4],
+    "hf_model": "dbmdz/bert-base-historic-multilingual-cased",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["hipe2020/de"],
+    "cuda": "0"
+}

configs/hipe2020/de/hmteams.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [8, 4],
+    "hf_model": "hmteams/teams-base-historic-multilingual-discriminator",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["hipe2020/de"],
+    "cuda": "0"
+}

configs/icdar/fr/hmbert.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "dbmdz/bert-base-historic-multilingual-cased",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["icdar/fr"],
+    "cuda": "0"
+}

configs/icdar/fr/hmteams.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "hmteams/teams-base-historic-multilingual-discriminator",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["icdar/fr"],
+    "cuda": "0"
+}

configs/icdar/multi/hmbert.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "dbmdz/bert-base-historic-multilingual-cased",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["icdar/fr", "icdar/nl"],
+    "cuda": "0"
+}

configs/icdar/multi/hmteams.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "hmteams/teams-base-historic-multilingual-discriminator",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["icdar/fr", "icdar/nl"],
+    "cuda": "0"
+}

configs/icdar/nl/hmbert.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "dbmdz/bert-base-historic-multilingual-cased",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["icdar/nl"],
+    "cuda": "0"
+}

configs/icdar/nl/hmteams.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "hmteams/teams-base-historic-multilingual-discriminator",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["icdar/nl"],
+    "cuda": "0"
+}

configs/letemps/fr/hmbert.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "dbmdz/bert-base-historic-multilingual-cased",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["letemps/fr"],
+    "cuda": "0"
+}

configs/letemps/fr/hmteams.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "hmteams/teams-base-historic-multilingual-discriminator",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["letemps/fr"],
+    "cuda": "0"
+}

configs/newseye/de/hmbert.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [8, 4],
+    "hf_model": "dbmdz/bert-base-historic-multilingual-cased",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["newseye/de"],
+    "cuda": "0"
+}

configs/newseye/de/hmteams.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [8, 4],
+    "hf_model": "hmteams/teams-base-historic-multilingual-discriminator",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["newseye/de"],
+    "cuda": "0"
+}

configs/newseye/fi/hmbert.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "dbmdz/bert-base-historic-multilingual-cased",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["newseye/fi"],
+    "cuda": "0"
+}

configs/newseye/fi/hmteams.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "hmteams/teams-base-historic-multilingual-discriminator",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["newseye/fi"],
+    "cuda": "0"
+}

configs/newseye/fr/hmbert.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [8, 4],
+    "hf_model": "dbmdz/bert-base-historic-multilingual-cased",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["newseye/fr"],
+    "cuda": "0"
+}

configs/newseye/fr/hmteams.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [8, 4],
+    "hf_model": "hmteams/teams-base-historic-multilingual-discriminator",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["newseye/fr"],
+    "cuda": "0"
+}

configs/newseye/multi/hmbert.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "dbmdz/bert-base-historic-multilingual-cased",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["newseye/fi", "newseye/sv"],
+    "cuda": "0"
+}

configs/newseye/multi/hmteams.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "hmteams/teams-base-historic-multilingual-discriminator",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["newseye/fi", "newseye/sv"],
+    "cuda": "0"
+}

configs/newseye/sv/hmbert.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "dbmdz/bert-base-historic-multilingual-cased",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["newseye/sv"],
+    "cuda": "0"
+}

configs/newseye/sv/hmteams.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "hmteams/teams-base-historic-multilingual-discriminator",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["newseye/sv"],
+    "cuda": "0"
+}

configs/topres19th/en/hmbert.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "dbmdz/bert-base-historic-multilingual-cased",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["topres19th/en"],
+    "cuda": "0"
+}

configs/topres19th/en/hmteams.json

@@ -0,0 +1,11 @@
+{
+    "seeds": [1,2,3,4,5],
+    "batch_sizes": [4, 8],
+    "hf_model": "hmteams/teams-base-historic-multilingual-discriminator",
+    "context_size": 0,
+    "epochs": [10],
+    "learning_rates": [3e-5, 5e-5],
+    "subword_poolings": ["first"],
+    "hipe_datasets": ["topres19th/en"],
+    "cuda": "0"
+}

flair-fine-tuner.py

@@ -0,0 +1,132 @@
+import json
+import logging
+import sys
+
+import flair
+import torch
+
+from typing import List
+
+from flair.data import MultiCorpus
+from flair.datasets import ColumnCorpus, NER_HIPE_2022, NER_ICDAR_EUROPEANA
+from flair.embeddings import (
+    TokenEmbeddings,
+    StackedEmbeddings,
+    TransformerWordEmbeddings
+)
+from flair import set_seed
+from flair.models import SequenceTagger
+from flair.trainers import ModelTrainer
+
+from utils import prepare_ajmc_corpus, prepare_clef_2020_corpus, prepare_newseye_fi_sv_corpus, prepare_newseye_de_fr_corpus
+
+logger = logging.getLogger("flair")
+logger.setLevel(level="INFO")
+
+
+def run_experiment(seed: int, batch_size: int, epoch: int, learning_rate: float, subword_pooling: str,
+                   hipe_datasets: List[str], json_config: dict):
+    hf_model = json_config["hf_model"]
+    context_size = json_config["context_size"]
+    layers = json_config["layers"] if "layers" in json_config else "-1"
+    use_crf = json_config["use_crf"] if "use_crf" in json_config else False
+
+    # Set seed for reproducibility
+    set_seed(seed)
+
+    corpus_list = []
+
+    # Dataset-related
+    for dataset in hipe_datasets:
+        dataset_name, language = dataset.split("/")
+
+        # E.g. topres19th needs no special preprocessing
+        preproc_fn = None
+
+        if dataset_name == "ajmc":
+            preproc_fn = prepare_ajmc_corpus
+        elif dataset_name == "hipe2020":
+            preproc_fn = prepare_clef_2020_corpus
+        elif dataset_name == "newseye" and language in ["fi", "sv"]:
+            preproc_fn = prepare_newseye_fi_sv_corpus
+        elif dataset_name == "newseye" and language in ["de", "fr"]:
+            preproc_fn = prepare_newseye_de_fr_corpus
+
+        if dataset_name == "icdar":
+            corpus_list.append(NER_ICDAR_EUROPEANA(language=language))
+        else:
+            corpus_list.append(NER_HIPE_2022(dataset_name=dataset_name, language=language, preproc_fn=preproc_fn,
+                                             add_document_separator=True))
+
+    if context_size == 0:
+        context_size = False
+
+    logger.info("FLERT Context: {}".format(context_size))
+    logger.info("Layers: {}".format(layers))
+    logger.info("Use CRF: {}".format(use_crf))
+
+    corpora: MultiCorpus = MultiCorpus(corpora=corpus_list, sample_missing_splits=False)
+    label_dictionary = corpora.make_label_dictionary(label_type="ner")
+    logger.info("Label Dictionary: {}".format(label_dictionary.get_items()))
+
+    embeddings = TransformerWordEmbeddings(
+        model=hf_model,
+        layers=layers,
+        subtoken_pooling=subword_pooling,
+        fine_tune=True,
+        use_context=context_size,
+    )
+
+    tagger: SequenceTagger = SequenceTagger(
+        hidden_size=256,
+        embeddings=embeddings,
+        tag_dictionary=label_dictionary,
+        tag_type="ner",
+        use_crf=use_crf,
+        use_rnn=False,
+        reproject_embeddings=False,
+    )
+
+    # Trainer
+    trainer: ModelTrainer = ModelTrainer(tagger, corpora)
+
+    datasets = "-".join([dataset for dataset in hipe_datasets])
+
+    trainer.fine_tune(
+        f"hmbench-{datasets}-{hf_model}-bs{batch_size}-ws{context_size}-e{epoch}-lr{learning_rate}-pooling{subword_pooling}-layers{layers}-crf{use_crf}-{seed}",
+        learning_rate=learning_rate,
+        mini_batch_size=batch_size,
+        max_epochs=epoch,
+        shuffle=True,
+        embeddings_storage_mode='none',
+        weight_decay=0.,
+        use_final_model_for_eval=False,
+    )
+
+    # Finally, print model card for information
+    tagger.print_model_card()
+
+
+if __name__ == "__main__":
+    filename = sys.argv[1]
+    with open(filename, "rt") as f_p:
+        json_config = json.load(f_p)
+
+    seeds = json_config["seeds"]
+    batch_sizes = json_config["batch_sizes"]
+    epochs = json_config["epochs"]
+    learning_rates = json_config["learning_rates"]
+    subword_poolings = json_config["subword_poolings"]
+
+    hipe_datasets = json_config["hipe_datasets"]  # Do not iterate over them
+
+    cuda = json_config["cuda"]
+    flair.device = f'cuda:{cuda}'
+
+    for seed in seeds:
+        for batch_size in batch_sizes:
+            for epoch in epochs:
+                for learning_rate in learning_rates:
+                    for subword_pooling in subword_poolings:
+                        run_experiment(seed, batch_size, epoch, learning_rate, subword_pooling, hipe_datasets,
+                                       json_config)  # pylint: disable=no-value-for-parameter

flair-log-parser.py

@@ -0,0 +1,93 @@
+import re
+import sys
+import numpy as np
+
+from collections import defaultdict
+from pathlib import Path
+from tabulate import tabulate
+
+# pattern = "bert-tiny-historic-multilingual-cased-*"  # sys.argv[1]
+pattern = sys.argv[1]
+
+log_dirs = Path("./").rglob(f"{pattern}")
+
+dev_results = defaultdict(list)
+test_results = defaultdict(list)
+
+for log_dir in log_dirs:
+    training_log = log_dir / "training.log"
+
+    if not training_log.exists():
+        print(f"No training.log found in {log_dir}")
+
+    matches = re.match(".*(bs.*?)-(ws.*?)-(e.*?)-(lr.*?)-layers-1-crfFalse-(\d+)", str(log_dir))
+
+    batch_size = matches.group(1)
+    ws = matches.group(2)
+    epochs = matches.group(3)
+    lr = matches.group(4)
+    seed = matches.group(5)
+
+    result_identifier = f"{ws}-{batch_size}-{epochs}-{lr}"
+
+    with open(training_log, "rt") as f_p:
+        all_dev_results = []
+        for line in f_p:
+            line = line.rstrip()
+
+            if "f1-score (micro avg)" in line:
+                dev_result = line.split(" ")[-1]
+                all_dev_results.append(dev_result)
+                # dev_results[result_identifier].append(dev_result)
+
+            if "F-score (micro" in line:
+                test_result = line.split(" ")[-1]
+                test_results[result_identifier].append(test_result)
+
+        best_dev_result = max([float(value) for value in all_dev_results])
+        dev_results[result_identifier].append(best_dev_result)
+
+mean_dev_results = {}
+
+print("Debug:", dev_results)
+
+for dev_result in dev_results.items():
+    result_identifier, results = dev_result
+
+    mean_result = np.mean([float(value) for value in results])
+
+    mean_dev_results[result_identifier] = mean_result
+
+print("Averaged Development Results:")
+
+sorted_mean_dev_results = dict(sorted(mean_dev_results.items(), key=lambda item: item[1], reverse=True))
+
+for mean_dev_config, score in sorted_mean_dev_results.items():
+    print(f"{mean_dev_config} : {round(score * 100, 2)}")
+
+best_dev_configuration = max(mean_dev_results, key=mean_dev_results.get)
+
+print("Markdown table:")
+
+print("")
+
+print("Best configuration:", best_dev_configuration)
+
+print("\n")
+
+print("Best Development Score:",
+      round(mean_dev_results[best_dev_configuration] * 100, 2))
+
+print("\n")
+
+header = ["Configuration"] + [f"Run {i + 1}" for i in range(len(dev_results[best_dev_configuration]))] + ["Avg."]
+
+table = []
+
+for mean_dev_config, score in sorted_mean_dev_results.items():
+    current_std = np.std(dev_results[mean_dev_config])
+    current_row = [f"`{mean_dev_config}`", *[round(res * 100, 2) for res in dev_results[mean_dev_config]],
+                   f"{round(score * 100, 2)} ± {round(current_std * 100, 2)}"]
+    table.append(current_row)
+
+print(tabulate(table, headers=header, tablefmt="github") + "\n")

requirements.txt

@@ -0,0 +1 @@
+git+https://github.com/flairNLP/flair.git@419f13a05d6b36b2a42dd73a551dc3ba679f820c

script.py

@@ -0,0 +1,48 @@
+# Expected environment variables:
+# CONFIG: points to *.json configuration file
+# HF_TOKEN: HF access token from https://huggingface.co/settings/tokens
+# REPO_NAME: name of HF datasets repo
+
+
+import os
+import flair
+import json
+import importlib
+
+from huggingface_hub import login, HfApi
+
+fine_tuner = importlib.import_module("flair-fine-tuner")
+
+config_file = os.environ.get("CONFIG")
+hf_token = os.environ.get("HF_TOKEN")
+repo_name = os.environ.get("REPO_NAME")
+
+login(token=hf_token, add_to_git_credential=True)
+api = HfApi()
+
+with open(config_file, "rt") as f_p:
+    json_config = json.load(f_p)
+
+seeds = json_config["seeds"]
+batch_sizes = json_config["batch_sizes"]
+epochs = json_config["epochs"]
+learning_rates = json_config["learning_rates"]
+subword_poolings = json_config["subword_poolings"]
+
+hipe_datasets = json_config["hipe_datasets"]  # Do not iterate over them
+
+cuda = json_config["cuda"]
+flair.device = f'cuda:{cuda}'
+
+for seed in seeds:
+    for batch_size in batch_sizes:
+        for epoch in epochs:
+            for learning_rate in learning_rates:
+                for subword_pooling in subword_poolings:
+                    fine_tuner.run_experiment(seed, batch_size, epoch, learning_rate, subword_pooling, hipe_datasets, json_config)
+                    api.upload_folder(
+                        folder_path="./",
+                        path_in_repo="./", # Upload to a specific folder
+                        repo_id=repo_name,
+                        repo_type="dataset",
+                    )

utils.py

@@ -0,0 +1,385 @@
+from flair.data import Sentence
+from flair.embeddings import TransformerWordEmbeddings
+
+from pathlib import Path
+
+from typing import List
+
+
+def prepare_ajmc_corpus(
+    file_in: Path, file_out: Path, eos_marker: str, document_separator: str, add_document_separator: bool
+):
+    with open(file_in, "rt") as f_p:
+        lines = f_p.readlines()
+
+    with open(file_out, "wt") as f_out:
+        # Add missing newline after header
+        f_out.write(lines[0] + "\n")
+
+        for line in lines[1:]:
+            if line.startswith(" \t"):
+                # Workaround for empty tokens
+                continue
+
+            line = line.strip()
+
+            # HIPE-2022 late pre-submission fix:
+            # Our hmBERT model has never seen Fraktur, so we replace long s
+            line = line.replace("ſ", "s")
+
+            # Add "real" document marker
+            if add_document_separator and line.startswith(document_separator):
+                f_out.write("-DOCSTART- O\n\n")
+
+            f_out.write(line + "\n")
+
+            if eos_marker in line:
+                    f_out.write("\n")
+
+    print("Special preprocessing for AJMC has finished!")
+
+
+def prepare_clef_2020_corpus(
+        file_in: Path, file_out: Path, eos_marker: str, document_separator: str, add_document_separator: bool
+):
+    with open(file_in, "rt") as f_p:
+        original_lines = f_p.readlines()
+
+    lines = []
+
+    # Add missing newline after header
+    lines.append(original_lines[0])
+
+    for line in original_lines[1:]:
+        if line.startswith(" \t"):
+            # Workaround for empty tokens
+            continue
+
+        line = line.strip()
+
+        # Add "real" document marker
+        if add_document_separator and line.startswith(document_separator):
+            lines.append("-DOCSTART- O")
+            lines.append("")
+
+        lines.append(line)
+
+        if eos_marker in line:
+            lines.append("")
+
+    # Now here comes the de-hyphenation part ;)
+    word_seperator = "¬"
+
+    for index, line in enumerate(lines):
+        if line.startswith("#"):
+            continue
+
+        if line.startswith(word_seperator):
+            continue
+
+        if not line:
+            continue
+
+        prev_line = lines[index - 1]
+
+        prev_prev_line = lines[index - 2]
+
+        if not prev_line.startswith(word_seperator):
+            continue
+
+        # Example:
+        # Po  <- prev_prev_line
+        # ¬   <- prev_line
+        # len <- current_line
+        #
+        # will be de-hyphenated to:
+        #
+        # Polen Dehyphenated-3
+        # # ¬
+        # # len
+        suffix = line.split("\t")[0]
+
+        prev_prev_line_splitted = lines[index - 2].split("\t")
+        prev_prev_line_splitted[0] += suffix
+
+        prev_line_splitted = lines[index - 1].split("\t")
+        prev_line_splitted[0] = "#" + prev_line_splitted[0]
+        prev_line_splitted[-1] += "|Commented"
+
+        current_line_splitted = line.split("\t")
+        current_line_splitted[0] = "#" + current_line_splitted[0]
+        current_line_splitted[-1] += "|Commented"
+
+        # Add some meta information about suffix length
+        # Later, it is possible to re-construct original token and suffix
+        prev_prev_line_splitted[9] += f"|Dehyphenated-{len(suffix)}"
+
+        lines[index - 2] = "\t".join(prev_prev_line_splitted)
+        lines[index - 1] = "\t".join(prev_line_splitted)
+        lines[index] = "\t".join(current_line_splitted)
+
+    # Post-Processing I
+    for index, line in enumerate(lines):
+        if not line:
+            continue
+
+        if not line.startswith(word_seperator):
+            continue
+
+        # oh noooo
+        current_line_splitted = line.split("\t")
+        current_line_splitted[0] = "#" + current_line_splitted[0]
+
+        current_line_splitted[-1] += "|Commented"
+
+        lines[index] = "\t".join(current_line_splitted)
+
+    # Post-Processing II
+    # Beautify: _|Commented –> Commented
+    for index, line in enumerate(lines):
+        if not line:
+            continue
+
+        if not line.startswith("#"):
+            continue
+
+        current_line_splitted = line.split("\t")
+
+        if current_line_splitted[-1] == "_|Commented":
+            current_line_splitted[-1] = "Commented"
+            lines[index] = "\t".join(current_line_splitted)
+
+    # Finally, save it!
+    with open(file_out, "wt") as f_out:
+        for line in lines:
+            f_out.write(line + "\n")
+
+
+def prepare_newseye_fi_sv_corpus(
+    file_in: Path, file_out: Path, eos_marker: str, document_separator: str, add_document_separator: bool
+):
+    with open(file_in, "rt") as f_p:
+        original_lines = f_p.readlines()
+
+    lines = []
+
+    # Add missing newline after header
+    lines.append(original_lines[0])
+
+    for line in original_lines[1:]:
+        if line.startswith(" \t"):
+            # Workaround for empty tokens
+            continue
+
+        line = line.strip()
+
+        # Add "real" document marker
+        if add_document_separator and line.startswith(document_separator):
+            lines.append("-DOCSTART- O")
+            lines.append("")
+
+        lines.append(line)
+
+        if eos_marker in line:
+            lines.append("")
+
+    # Now here comes the de-hyphenation part
+    # And we want to avoid matching "-DOCSTART-" lines here, so append a tab
+    word_seperator = "-\t"
+
+    for index, line in enumerate(lines):
+        if line.startswith("#"):
+            continue
+
+        if line.startswith(word_seperator):
+            continue
+
+        if not line:
+            continue
+
+        prev_line = lines[index - 1]
+
+        prev_prev_line = lines[index - 2]
+
+        if not prev_line.startswith(word_seperator):
+            continue
+
+        # Example:
+        # Po  NoSpaceAfter <- prev_prev_line
+        # -   <- prev_line
+        # len <- current_line
+        #
+        # will be de-hyphenated to:
+        #
+        # Polen Dehyphenated-3
+        # # -
+        # # len
+        #
+        # It is really important, that "NoSpaceAfter" in the previous
+        # line before hyphenation character! Otherwise, it is no real
+        # hyphenation!
+
+        if not "NoSpaceAfter" in prev_line:
+            continue
+
+        if not prev_prev_line:
+            continue
+
+        suffix = line.split("\t")[0]
+
+        prev_prev_line_splitted = lines[index - 2].split("\t")
+        prev_prev_line_splitted[0] += suffix
+
+        prev_line_splitted = lines[index - 1].split("\t")
+        prev_line_splitted[0] = "# " + prev_line_splitted[0]
+        prev_line_splitted[-1] += "|Commented"
+
+        current_line_splitted = line.split("\t")
+        current_line_splitted[0] = "# " + current_line_splitted[0]
+        current_line_splitted[-1] += "|Commented"
+
+        # Add some meta information about suffix length
+        # Later, it is possible to re-construct original token and suffix
+        prev_prev_line_splitted[9] += f"|Dehyphenated-{len(suffix)}"
+
+        lines[index - 2] = "\t".join(prev_prev_line_splitted)
+        lines[index - 1] = "\t".join(prev_line_splitted)
+        lines[index]     = "\t".join(current_line_splitted)
+
+    # Post-Processing I
+    for index, line in enumerate(lines):
+        if not line:
+            continue
+
+        if not line.startswith(word_seperator):
+            continue
+
+        # oh noooo
+        current_line_splitted = line.split("\t")
+        current_line_splitted[0] = "# " + current_line_splitted[0]
+
+        current_line_splitted[-1] += "|Commented"
+
+        lines[index] = "\t".join(current_line_splitted)
+
+    # Post-Processing II
+    # Beautify: _|Commented –> Commented
+    for index, line in enumerate(lines):
+        if not line:
+            continue
+
+        if not line.startswith("#"):
+            continue
+
+        current_line_splitted = line.split("\t")
+
+        if current_line_splitted[-1] == "_|Commented":
+            current_line_splitted[-1] = "Commented"
+            lines[index] = "\t".join(current_line_splitted)
+
+    # Finally, save it!
+    with open(file_out, "wt") as f_out:
+        for line in lines:
+            f_out.write(line + "\n")
+
+
+def prepare_newseye_de_fr_corpus(
+    file_in: Path, file_out: Path, eos_marker: str, document_separator: str, add_document_separator: bool
+):
+    with open(file_in, "rt") as f_p:
+        original_lines = f_p.readlines()
+
+    lines = []
+
+    # Add missing newline after header
+    lines.append(original_lines[0])
+
+    for line in original_lines[1:]:
+        if line.startswith(" \t"):
+            # Workaround for empty tokens
+            continue
+
+        line = line.strip()
+
+        # Add "real" document marker
+        if add_document_separator and line.startswith(document_separator):
+            lines.append("-DOCSTART- O")
+            lines.append("")
+
+        lines.append(line)
+
+        if eos_marker in line:
+            lines.append("")
+
+    # Now here comes the de-hyphenation part ;)
+    word_seperator = "¬"
+
+    for index, line in enumerate(lines):
+        if line.startswith("#"):
+            continue
+
+        if not line:
+            continue
+
+        last_line = lines[index - 1]
+        last_line_splitted = last_line.split("\t")
+
+        if not last_line_splitted[0].endswith(word_seperator):
+            continue
+
+        # The following example
+        #
+        # den   O   O   O   null    null    SpaceAfter
+        # Ver¬  B-LOC   O   O   null    n                  <- last_line
+        # einigten  I-LOC   O   O   null    n   SpaceAfter <- current_line
+        # Staaten   I-LOC   O   O   null    n
+        # . O   O   O   null    null
+        #
+        # will be transformed to:
+        #
+        # den   O   O   O   null    null    SpaceAfter
+        # Vereinigten   B-LOC   O   O   null    n   |Normalized-8
+        # #einigten I-LOC   O   O   null    n   SpaceAfter|Commented
+        # Staaten   I-LOC   O   O   null    n
+        # . O   O   O   null    null
+
+        suffix = last_line.split("\t")[0].replace(word_seperator, "")  # Will be "Ver" 
+
+        prefix_length = len(line.split("\t")[0])
+
+        # Override last_line:
+        # Ver¬ will be transformed to Vereinigten with normalized information at the end
+
+        last_line_splitted[0] = suffix + line.split("\t")[0]
+
+        last_line_splitted[9] += f"|Dehyphenated-{prefix_length}"
+
+        current_line_splitted = line.split("\t")
+        current_line_splitted[0] = "# " + current_line_splitted[0]
+        current_line_splitted[-1] += "|Commented"
+
+        lines[index - 1] = "\t".join(last_line_splitted)
+        lines[index]     = "\t".join(current_line_splitted)
+
+    # Post-Processing I
+    # Beautify: _|Commented –> Commented
+    for index, line in enumerate(lines):
+        if not line:
+            continue
+
+        if not line.startswith("#"):
+            continue
+
+        current_line_splitted = line.split("\t")
+
+        if current_line_splitted[-1] == "_|Commented":
+            current_line_splitted[-1] = "Commented"
+            lines[index] = "\t".join(current_line_splitted)
+
+    # Finally, save it!
+    with open(file_out, "wt") as f_out:
+        for line in lines:
+            f_out.write(line + "\n")
+
+    print("Special preprocessing for German/French NewsEye dataset has finished!")
+