Upload non-data

.gitattributes

@@ -1,55 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
+# Auto detect text files and perform LF normalization
+* text=auto

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

README.md

@@ -0,0 +1,135 @@
+# PERO OCR NER 1.0
+
+Dataset
+
+This is a dataset created for master thesis "Document Information Extraction".  
+Author: Roman Janík (xjanik20), 2023  
+Faculty of Information Technology, Brno University of Technology
+
+## Description
+
+This is a **P**ERO **O**CR **NER** 1.0 dataset for Named Entity Recognition. The dataset consists of 9,310 Czech sentences with 14,639 named entities.
+Source data are Czech historical chronicles mostly from the first half of the 20th century. The chronicles scanned images were processed by PERO OCR [1]. 
+Text data were then annotated in the Label Studio tool. The process was semi-automated, first a NER model was used to pre-annotate the data and then 
+the pre-annotations were manually refined. Named entity types are: *Personal names*, *Institutions*, *Geographical names*, *Time expressions*, and *Artifact names/Objects*; the same as in Czech Historical Named Entity Corpus (CHNEC)[2]. 
+
+The CoNLL files are formatted as follows:
+
+Each line in
+the corpus contains information about one word/token. The first column is the actual
+word, and the second column is a Named Entity class in a BIO format. An empty line is a sentence separator.
+
+For detailed documentation, please see [doc/documentation.pdf](https://github.com/roman-janik/PONER/blob/main/doc/documentation.pdf). In case of any question, please use GitHub Issues.
+
+## Results
+
+This dataset was used for training several NER models.
+
+### RobeCzech
+
+RobeCzech [3], a Czech version of RoBERTa [4] model was finetuned using PONER, CHNEC [2], and Czech Named Entity Corpus (CNEC)[5]. All datasets train and test splits were concatenated and used together during training and the model was then evaluated separately on each dataset.
+
+
+| Model     | CNEC 2.0 test  |  CHNEC 1.0 test  | PONER 1.0 test  |
+| --------- | --------- | --------- | --------- |
+| RobeCzech | 0.886 | 0.876 | **0.871** |
+
+### Czech RoBERTa models
+
+ Smaller versions of RoBERTa [4] model were trained on an own text dataset and then finetuned using PONER, CHNEC [2] and Czech Named Entity Corpus (CNEC)[5]. All datasets train and test splits were concatenated and used together during training and the model was then evaluated separately on each dataset. Two configurations were used:  CNEC + CHNEC + PONER and PONER.
+
+
+| Model     | Configuration | CNEC 2.0 test | CHNEC 1.0 test | PONER 1.0 test  |
+| --------- | --------- | --------- | --------- | --------- |
+| Czech RoBERTa 8L_512H| CNEC + CHNEC + PONER | 0.800 | 0.867 | **0.841** |
+| Czech RoBERTa 8L_512H | PONER | - | - | **0.832** |
+
+## Data
+
+Data are organized as follows: `data/conll` contains dataset CoNLL files, with whole data in `poner.conll` and splits used 
+for training in the original thesis. These splits are 0.45/0.50/0.05 for train/test/dev. You can create your own splits with `scripts/split_poner_dataset_conll.py`. `data/hugging_face` contains original splits in the Hugging Face format. `data/label_studio_annotations`
+contains the final Label Studio JSON export file. `data/source_data` contains original text and image files of annotated pages.
+
+#### Examples
+
+CoNLL:
+
+```
+Od O
+9. B-t
+listopadu I-t
+1895 I-t
+zastupoval O
+starostu O
+Fr B-p
+. I-p
+Štěpka I-p
+zemřel O
+2. B-t
+února I-t
+1896 I-t
+) O
+pan O
+Jindřich B-p
+Matzenauer I-p
+. O
+
+```
+
+Label Studio page:
+
+![Label Studio page example](img/label-studio-task-overview.png)
+
+## Scripts
+
+Directory `scripts` contain Python scripts used for the creation of the dataset. There are two scripts for
+editing Label Studio JSON annotation file, one for creating CoNLL version out of an annotation file and text files,
+one for creating splits and one for loading CoNNL files and transforming them to the Hugging Face dataset format. Scripts are written in Python 10.0.
+To be able to run all scripts, in the scripts directory run the:
+
+```shellscript
+pip install  -r requirements.txt
+```
+
+## License
+
+PONER is licensed under the Apache License Version 2.0.
+
+## Citation
+
+If you use PONER in your work, please cite the
+[Document Information Extraction](https://dspace.vutbr.cz/handle/11012/213801?locale-attribute=en).
+
+```
+@mastersthesis{janik-2023-document-information-extraction,
+    title = "Document Information Extraction",
+    author = "Janík, Roman",
+    language = "eng",
+    year = "2023",
+    school = "Brno University of Technology, Faculty of Information Technology",
+    url = "https://dspace.vutbr.cz/handle/11012/213801?locale-attribute=en",
+    type = "Master’s thesis",
+    note = "Supervisor Ing. Michal Hradiš, Ph.D."
+}
+```
+
+## References
+[1] - **O Kodym, M Hradiš**: *Page Layout Analysis System for Unconstrained Historic Documents.* ICDAR, 2021, [PERO OCR](https://pero-ocr.fit.vutbr.cz/).
+
+[2] - **Hubková, H., Kral, P. and Pettersson, E.** Czech Historical Named Entity
+Corpus v 1.0. In: *Proceedings of the 12th Language Resources and Evaluation Conference.* Marseille, France: European Language Resources Association, May 2020, p. 4458–4465. ISBN 979-10-95546-34-4. Available at:
+https://aclanthology.org/2020.lrec-1.549.
+
+[3] - **Straka, M., Náplava, J., Straková, J. and Samuel, D.** RobeCzech: Czech
+RoBERTa, a Monolingual Contextualized Language Representation Model. In: *24th
+International Conference on Text, Speech and Dialogue.* Cham, Switzerland:
+Springer, 2021, p. 197–209. ISBN 978-3-030-83526-2.
+
+[4] - **Liu, Y., Ott, M., Goyal, N., Du, J., Joshi, M. et al.** RoBERTa: A Robustly
+Optimized BERT Pretraining Approach. 2019. Available at:
+http://arxiv.org/abs/1907.11692.
+
+[5] - **Ševčíková, M., Žabokrtský, Z., Straková, J. and Straka, M.** Czech Named
+Entity Corpus 2.0. 2014. LINDAT/CLARIAH-CZ digital library at the Institute of Formal
+and Applied Linguistics (ÚFAL), Faculty of Mathematics and Physics, Charles University.
+Available at: http://hdl.handle.net/11858/00-097C-0000-0023-1B22-8.

scripts/adjust_annotation_end.py

@@ -0,0 +1,226 @@
+# Author: Roman Janík
+# Script for adjusting the end of entity annotation span in text. Label Studio marks additional characters
+# at the end of entity, which do not belong to it (usually dot or comma).
+#
+
+import argparse
+import json
+import re
+
+from pynput import keyboard
+from pynput.keyboard import Key
+
+
+def get_args():
+    parser = argparse.ArgumentParser(description="Script for adjusting the end of entity annotation span in text. Label\
+                                      Studio marks additional characters at the end of entity, which do not belong to it\
+                                      (usually dot or comma).")
+    parser.add_argument("-s", "--source_file", required=True, help="Path to source Label Studio json annotations file.")
+    args = parser.parse_args()
+    return args
+
+
+def save(annotations_file, annotations):
+    with open(annotations_file, "w", encoding='utf8') as f:
+        json.dump(annotations, f, indent=2, ensure_ascii=False)
+    print("Annotations were saved!")
+
+
+def auto_correct(n_entity_text, n_entity_type):
+    if len(n_entity_text) >= 2 and n_entity_text[-2].isalnum() and n_entity_text[-1] == "\n":
+        return 1
+
+    if n_entity_type == "Artifact names/Objects":
+        monetary_u = ["zl.", "kr.", "zl. r. m.", "kr. r. m.", "tol.", "zl. r. č.", "h.", "hal.", "fl.", "gr."]
+        if n_entity_text in monetary_u:
+            return 0
+        to_be_determined = ["Uh.", "př.", "č.", "R.", "lt.", "r.", "J. K. K.", "sv. Karla\nBor.",
+                            "čís. 80. Sov. zák. a nař.", "čís. 80\nSb. z. a n."]
+        if n_entity_text in to_be_determined:
+            return -1
+        if n_entity_text.endswith("Sb."):
+            return 0
+        if len(n_entity_text) >= 2 and n_entity_text[-2].isalnum():
+            return 1
+
+    if n_entity_type == "Time expressions":
+        # year
+        if re.search("^[0-9]{4}$", n_entity_text[:-1]):
+            return 1
+        # single day
+        if re.search("^[0-9][.]$|^[0-9]{2}[.]$", n_entity_text):
+            return 0
+        # single day with comma
+        if re.search("^[0-9][,]$|^[0-9]{2}[,]$", n_entity_text):
+            return 1
+        # day and month
+        if re.search("^[0-9][.][ ]?[0-9][.]$|^[0-9][.][ ]?[0-9]{2}[.]$|^[0-9]{2}[.][ ]?[0-9][.]$|^[0-9]{2}[.][ ]?["
+                     "0-9]{2}[.]$", n_entity_text):
+            return 0
+        # year span
+        if re.search("^[0-9]{4}[ ]?[-][ ]?[0-9]{4}$|^[0-9]{4}[ ]?[-][ ]?[0-9]{2}$", n_entity_text[:-1]):
+            return 1
+        # date with "hod." or "t.r." at the end
+        if n_entity_text.endswith(("hod.", "t.r.", "t. r.", "t.m.", "t. m.")):
+            return 0
+
+    if n_entity_type == "Geographical names":
+        # street name correct
+        if n_entity_text.endswith(("ul.", "tř.", "nám.")):
+            return 0
+        # street name incorrect
+        if n_entity_text.endswith(("ul.,", "tř.,", "nám.,")):
+            return 1
+
+    if n_entity_type == "Personal names":
+        # names ending with "ml." or "st." correct
+        if n_entity_text.endswith(("ml.", "st.")):
+            return 0
+        # names ending with "ml." or "st." incorrect
+        if n_entity_text.endswith(("ml.,", "st.,")):
+            return 1
+
+    if n_entity_type == "Institutions":
+        # M.N.V., O.N.V., K.N.V., N.J., N.F., J.Z.D.
+        if re.search("^[M][.][ ]?[N][.][ ]?[V][.]$|^[O][.][ ]?[N][.][ ]?[V][.]$|^[K][.][ ]?[N][.][ ]?[V][.]$|^[N][.][ "
+                     "]?[J][.]$|^[N][.][ ]?[F][.]|^[J][.][ ]?[Z][.][ ]?[D][.]$", n_entity_text):
+            return 0
+        # M.N.V., O.N.V., K.N.V., N.J., N.F., J.Z.D. with additional char
+        if re.search(
+                "^[M][.][ ]?[N][.][ ]?[V][.]$|^[O][.][ ]?[N][.][ ]?[V][.]$|^[K][.][ ]?[N][.][ ]?[V][.]$|^[N][.][ "
+                "]?[J][.]$|^[N][.][ ]?[F][.]|^[J][.][ ]?[Z][.][ ]?[D][.]$", n_entity_text[:-1]):
+            return 1
+        if n_entity_text[:-1] in ["JZD", "KSČ", "Ksč", "ksč", "Kčs", "ksč", "NF", "MNV", "ONV", "KNV"]:
+            return 1
+
+    if n_entity_type in ["Geographical names", "Personal names", "Institutions"]:
+        # shorten entities with non-dot char at the end
+        if n_entity_text[-1] != ".":
+            words = n_entity_text[:-1].split()
+            if all([word.isalnum() for word in words]):
+                return 1
+
+    return -1
+
+
+def main():
+    args = get_args()
+
+    print("Script for adjusting the end of entity annotation span in text. "
+          "Script goes through page text files and their annotations json record. "
+          "End of entity is adjusted manually or automatically is possible and annotations are saved to the same file."
+          "Adjusting starts at last adjusted entity, controls: right arrow - next entity, left arrow - previous entity,"
+          "up arrow - +1 length, down arrow - -1 length, s - save"
+          "automatic save after 10 entities\n")
+
+    def on_key_release(key):
+        nonlocal annotations, n_entity_idx, page_idx, page_text, stop_edit, adjusted_n_entities
+
+        # next entity
+        if key == Key.right:
+            annotations[page_idx]["ner"][n_entity_idx]["adjusted"] = True
+            n_entity_idx += 1
+            adjusted_n_entities += 1
+            exit()
+        # previous adjusted entity
+        elif key == Key.left:
+            while n_entity_idx > 0:
+                n_entity_idx -= 1
+                if "adjusted" in annotations[page_idx]["ner"][n_entity_idx].keys():
+                    annotations[page_idx]["ner"][n_entity_idx]["adjusted"] = False
+                    adjusted_n_entities -= 1
+                    break
+            exit()
+        # +1 length
+        elif key == Key.up:
+            if annotations[page_idx]["ner"][n_entity_idx]["end"] + 1 == len(page_text):
+                print("Entity span cannot be prolonged, end of page text is reached!")
+            else:
+                annotations[page_idx]["ner"][n_entity_idx]["end"] += 1
+                print("Entity length + 1, end:   {}".format(annotations[page_idx]["ner"][n_entity_idx]["end"]))
+        # -1 length
+        elif key == Key.down:
+            if annotations[page_idx]["ner"][n_entity_idx]["end"] - 1 == 0:
+                print("Entity span cannot be shortened, start of page text is reached!")
+            else:
+                annotations[page_idx]["ner"][n_entity_idx]["end"] -= 1
+                print("Entity length - 1, end:   {}".format(annotations[page_idx]["ner"][n_entity_idx]["end"]))
+        # save
+        elif key == Key.esc:
+            save(args.source_file, annotations)
+            print("Editing stopped!")
+            stop_edit = True
+            exit()
+
+    with open(args.source_file, encoding="utf-8") as f:
+        annotations = json.load(f)
+
+    page_idx = 0
+    n_entity_idx = 0
+    for i, page in enumerate(annotations):
+        if "adjusted" not in page.keys() or not page["adjusted"]:
+            page_idx = i
+            for j, n_entity in enumerate(page["ner"]):
+                if "adjusted" not in n_entity.keys():
+                    n_entity_idx = j
+                    break
+            break
+
+    adjusted_pages = 0
+    adjusted_n_entities = 1
+    stop_edit = False
+    while True:
+        page_text_path = annotations[page_idx]["text"].replace(
+            "http://localhost:8081", "../../../datasets/poner1.0/data")
+        with open(page_text_path, encoding="utf-8") as p_f:
+            page_text = p_f.read()
+        page_name = annotations[page_idx]["page_name"]
+        print(f"Page:   {adjusted_pages}\n{page_name}\n{page_text}\n\nEntities without alphanum end:\n")
+
+        while True:
+            n_entity = annotations[page_idx]["ner"][n_entity_idx]
+            n_entity_text = page_text[n_entity["start"]:n_entity["end"]]
+            n_entity_type = n_entity["labels"][0]
+            if not n_entity_text[-1].isalnum() or ("adjusted" in n_entity.keys() and not n_entity["adjusted"]):
+                # try auto correct function, if auto correction is not possible, manual correction is applied
+                end_shift = auto_correct(n_entity_text, n_entity_type)
+                if end_shift == -1 or ("adjusted" in n_entity.keys() and not n_entity["adjusted"]):
+                    context_start = 0 if n_entity["start"] - 100 < 0 else n_entity["start"] - 100
+                    context_end = len(page_text) - 1 if n_entity["start"] + 100 >= len(page_text) \
+                        else n_entity["start"] + 100
+                    print(
+                        f"\n{n_entity_text}\n------------------------------\n{n_entity_type}\n"
+                        f"------------------------------\n{page_text[context_start:context_end]}\n")
+                    with keyboard.Listener(on_release=on_key_release) as listener:
+                        listener.join()
+                    if stop_edit:
+                        return
+                else:
+                    # auto correction application
+                    annotations[page_idx]["ner"][n_entity_idx]["end"] -= end_shift
+                    annotations[page_idx]["ner"][n_entity_idx]["auto_adjusted"] = True
+                    n_entity_idx += 1
+                    adjusted_n_entities += 1
+
+                # auto save
+                if adjusted_n_entities % 10 == 0:
+                    save(args.source_file, annotations)
+            else:
+                n_entity_idx += 1
+            if n_entity_idx == len(annotations[page_idx]["ner"]):
+                n_entity_idx = 0
+                break
+
+        adjusted_pages += 1
+
+        annotations[page_idx]["adjusted"] = True
+        page_idx += 1
+        if page_idx == len(annotations):
+            save(args.source_file, annotations)
+            break
+
+    print("All pages were adjusted!")
+
+
+if __name__ == '__main__':
+    main()

scripts/create_poner_dataset_conll.py

@@ -0,0 +1,112 @@
+# Author: Roman Janík
+# Script for creating a CoNLL format of my dataset from text files and Label Studio annotations.
+#
+
+import argparse
+import json
+import os
+
+from nltk.tokenize import word_tokenize, sent_tokenize
+
+
+def get_args():
+    parser = argparse.ArgumentParser(description="Script for creating a CoNLL format of my dataset from text files and Label Studio annotations.")
+    parser.add_argument("-s", "--source_file", required=True, help="Path to source Label Studio json annotations file.")
+    parser.add_argument("-o", "--output_dir", required=True, help="Output dir for CoNLL dataset splits.")
+    args = parser.parse_args()
+    return args
+
+
+def fix_quotes(sentence):
+    return map(lambda word: word.replace('``', '"').replace("''", '"'), sentence)
+
+
+def process_text_annotations(text, annotations):
+    entity_types_map = {
+        "Personal names": "p",
+        "Institutions": "i",
+        "Geographical names": "g",
+        "Time expressions": "t",
+        "Artifact names/Objects": "o"
+    }
+
+    sentences = sent_tokenize(text, language="czech")
+    sentences_t = [fix_quotes(word_tokenize(x, language="czech")) for x in sentences]
+
+    sentences_idx = []
+    start = 0
+    for i, c in enumerate(text):
+        if not c.isspace():
+            start = i
+            break
+
+    for sentence in sentences_t:
+        sentence_idx = []
+        for word in sentence:
+            end = start + len(word)
+            sentence_idx.append({"word": word, "start": start, "end": end, "entity_type": "O"})
+            for i, _ in enumerate(text):
+                if end + i < len(text) and not text[end + i].isspace():
+                    start = end + i
+                    break
+        sentences_idx.append(sentence_idx)
+
+    for n_entity in annotations:
+        begin = True
+        done = False
+        for sentence_idx in sentences_idx:
+            for word_idx in sentence_idx:
+                if word_idx["start"] >= n_entity["start"]\
+                        and (word_idx["end"] <= n_entity["end"]
+                             or (not text[word_idx["end"]-1].isalnum()) and len(word_idx["word"]) > 1) and begin:
+                    word_idx["entity_type"] = "B-" + entity_types_map[n_entity["labels"][0]]
+                    begin = False
+                    if word_idx["end"] >= n_entity["end"]:
+                        done = True
+                        break
+                elif word_idx["start"] > n_entity["start"] and (word_idx["end"] <= n_entity["end"]
+                    or (not text[word_idx["end"]-1].isalnum() and text[word_idx["start"]].isalnum())):
+                    word_idx["entity_type"] = "I-" + entity_types_map[n_entity["labels"][0]]
+                    if word_idx["end"] >= n_entity["end"]:
+                        done = True
+                        break
+                elif word_idx["end"] > n_entity["end"]:
+                    done = True
+                    break
+            if done:
+                break
+
+    conll_sentences = []
+    for sentence_idx in sentences_idx:
+        conll_sentence = map(lambda w: w["word"] + " " + w["entity_type"], sentence_idx)
+        conll_sentences.append("\n".join(conll_sentence))
+    conll_sentences = "\n\n".join(conll_sentences)
+
+    return conll_sentences
+
+
+def main():
+    args = get_args()
+
+    print("Script for creating a CoNLL format of my dataset from text files and Label Studio annotations."
+          "Script goes through page text files and their annotations json record. "
+          "Output CoNLL dataset file is saved to output directory.")
+
+    with open(args.source_file, encoding="utf-8") as f:
+        annotations = json.load(f)
+
+    print("Starting documents processing...")
+
+    with open(os.path.join(args.output_dir, "poner.conll"), "w", encoding="utf-8") as f:
+        for page in annotations:
+            page_text_path = page["text"].replace("http://localhost:8081", "../../../datasets/poner1.0/data")
+            with open(page_text_path, encoding="utf-8") as p_f:
+                page_text = p_f.read()
+                processed_page = process_text_annotations(page_text, page["ner"])
+                f.write(processed_page + "\n\n")
+
+    print("Annotations are processed.")
+
+
+if __name__ == '__main__':
+    main()

scripts/poner-1_0.py

@@ -0,0 +1,132 @@
+# Author: Roman Janík
+# Script for local loading PONER 1.0 CoNNL dataset and converting it to Hugging Face dataset format.
+#
+# This script if a modified version of conll2003/conll2003.py script by HuggingFace Datasets Authors.
+#
+# 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.
+
+import os
+import datasets
+
+
+logger = datasets.logging.get_logger(__name__)
+
+
+_CITATION = """
+-
+"""
+
+_DESCRIPTION = """\
+This is a Pero OCR NER 1.0 dataset in the CoNLL format. Each line in
+the corpus contains information about one word/token. The first column is the actual
+word, the second column is a Named Entity class in a BIO format. An empty line is a sentence separator.
+"""
+
+_TRAINING_FILE = "poner_train.conll"
+_DEV_FILE = "poner_dev.conll"
+_TEST_FILE = "poner_test.conll"
+
+
+class Poner1_0ConllConfig(datasets.BuilderConfig):
+    """BuilderConfig for PONER 1.0 CoNNL"""
+
+    def __init__(self, **kwargs):
+        """BuilderConfig for PONER 1.0 CoNNL.
+        Args:
+          **kwargs: keyword arguments forwarded to super.
+        """
+        super(Poner1_0ConllConfig, self).__init__(**kwargs)
+
+
+class Poner1_0Conll(datasets.GeneratorBasedBuilder):
+    """PONER 1.0 CoNNL dataset."""
+
+    BUILDER_CONFIGS = [
+        Poner1_0ConllConfig(name="poner1_0conll", version=datasets.Version("1.0.0"),
+                            description="PONER 1.0 CoNNL dataset"),
+    ]
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "id": datasets.Value("string"),
+                    "tokens": datasets.Sequence(datasets.Value("string")),
+                    "ner_tags": datasets.Sequence(
+                        datasets.features.ClassLabel(
+                            names=[
+                                "O",
+                                "B-p",
+                                "I-p",
+                                "B-i",
+                                "I-i",
+                                "B-g",
+                                "I-g",
+                                "B-t",
+                                "I-t",
+                                "B-o",
+                                "I-o"
+                            ]
+                        )
+                    ),
+                }
+            ),
+            supervised_keys=None,
+            homepage="https://pero-ocr.fit.vutbr.cz",
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager, dataset_path="../../../datasets/poner1.0"):
+        """Returns SplitGenerators."""
+        data_files = {
+            "train": os.path.join(dataset_path, _TRAINING_FILE),
+            "dev": os.path.join(dataset_path, _DEV_FILE),
+            "test": os.path.join(dataset_path, _TEST_FILE),
+        }
+
+        return [
+            datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"filepath": data_files["train"]}),
+            datasets.SplitGenerator(name=datasets.Split.VALIDATION, gen_kwargs={"filepath": data_files["dev"]}),
+            datasets.SplitGenerator(name=datasets.Split.TEST, gen_kwargs={"filepath": data_files["test"]}),
+        ]
+
+    def _generate_examples(self, filepath):
+        logger.info("⏳ Generating examples from = %s", filepath)
+        with open(filepath, encoding="utf-8") as f:
+            guid = 0
+            tokens = []
+            ner_tags = []
+            for line in f:
+                if line.startswith("-DOCSTART-") or line == "" or line == "\n":
+                    if tokens:
+                        yield guid, {
+                            "id": str(guid),
+                            "tokens": tokens,
+                            "ner_tags": ner_tags,
+                        }
+                        guid += 1
+                        tokens = []
+                        ner_tags = []
+                else:
+                    # conll2003 tokens are space separated
+                    splits = line.split(" ")
+                    tokens.append(splits[0])
+                    ner_tags.append(splits[1].rstrip())
+            # last example
+            if tokens:
+                yield guid, {
+                    "id": str(guid),
+                    "tokens": tokens,
+                    "ner_tags": ner_tags,
+                }

scripts/remove_start_whitespace.py

@@ -0,0 +1,72 @@
+# Author: Roman Janík
+# Script for removing whitespace at the start of entity annotation span in text. Label Studio marks additional
+# whitespace at the start of entity, which do not belong to it (usually newline). Phantom entities created by
+# a model with only one newline char in front of real entity are removed. Single non alphanumeric entities are
+# removed too.
+#
+
+import argparse
+import json
+
+
+def get_args():
+    parser = argparse.ArgumentParser(description="""Script for removing whitespace at the start of entity annotation
+ span in text. Label Studio marks additional whitespace at the start of entity, which do not belong to it 
+ (usually newline). Phantom entities created by a model with only one newline char in front of real entity are removed.
+ Single non alphanumeric entities are removed too.""")
+    parser.add_argument("-s", "--source_file", required=True, help="Path to source Label Studio json annotations file.")
+    args = parser.parse_args()
+    return args
+
+
+def save(annotations_file, annotations):
+    with open(annotations_file, "w", encoding='utf8') as f:
+        json.dump(annotations, f, indent=2, ensure_ascii=False)
+    print("Annotations were saved!")
+
+
+def main():
+    args = get_args()
+
+    print("Script for removing whitespace at the start of entity annotation span in text. "
+          "Script goes through page text files and their annotations json record. "
+          "Whitespace and quotes at the start of entity are removed and annotations are saved to the same file."
+          "Single non alphanumeric entities are removed too.")
+
+    with open(args.source_file, encoding="utf-8") as f:
+        annotations = json.load(f)
+
+    short_count = 0
+    rem_count = 0
+    total_entities = 0
+    for i, page in enumerate(annotations):
+        page_text_path = annotations[i]["text"].replace(
+            "http://localhost:8081", "../../../datasets/poner1.0/data")
+        with open(page_text_path, encoding="utf-8") as p_f:
+            page_text = p_f.read()
+
+        for j, n_entity in enumerate(page["ner"]):
+            n_entity_text = page_text[n_entity["start"]:n_entity["end"]]
+            if n_entity_text[0].isspace():
+                if len(n_entity_text) == 1:
+                    rem_count += 1
+                    annotations[i]["ner"].pop(j)
+                else:
+                    short_count += 1
+                    annotations[i]["ner"][j]["start"] += 1
+            if len(n_entity_text) == 1 and not n_entity_text.isalnum():
+                rem_count += 1
+                annotations[i]["ner"].pop(j)
+            if n_entity_text[0] == "„":
+                short_count += 1
+                annotations[i]["ner"][j]["start"] += 1
+        total_entities += len(annotations[i]["ner"])
+
+    save(args.source_file, annotations)
+    average_entities = total_entities / len(annotations)
+    print(f"All pages were processed! Num corrected entities: {short_count}, num removed phantom entities: {rem_count}"
+          f"\nAverage entities in 1 page: {average_entities}, Total entities: {total_entities}")
+
+
+if __name__ == '__main__':
+    main()

scripts/requirements.txt

@@ -0,0 +1,10 @@
+transformers~=4.28.1
+tqdm~=4.64.1
+seqeval~=1.2.2
+datasets[vision]~=2.11.0
+evaluate~=0.2.2
+accelerate~=0.18.0
+tokenizers~=0.13.3
+tensorboard~=2.10.1
+torchvision
+nltk~=3.8.1

scripts/split_poner_dataset_conll.py

@@ -0,0 +1,82 @@
+# Author: Roman Janík
+# Script for creating splits of a CoNLL format of my dataset.
+#
+
+import argparse
+import os
+
+from random import shuffle
+from itertools import islice
+
+
+def get_args():
+    parser = argparse.ArgumentParser(description="Script for creating splits of a CoNLL format of my dataset.")
+    parser.add_argument("-s", "--source_file", required=True, help="Path to source Label Studio json annotations file.")
+    parser.add_argument("-o", "--output_dir", required=True, help="Output dir for CoNLL dataset splits.")
+    parser.add_argument("-m", "--shuffle", default=True, dest="shuffle", action="store_true",
+                        help="Shuffle annotations.")
+    parser.add_argument("--shuffle_chunk", type=int, default=1, dest="shuffle_chunk",
+                        help="Shuffle annotations chunk. Chunk annotations, shuffle and join back.")
+    parser.add_argument("-p", "--split_ratios", required=True,
+                        help="Ratios for train/dev/test splits, nums separated by ':'")
+    args = parser.parse_args()
+    return args
+
+
+def parse_splits(split_str: str):
+    split_list = split_str.split(":")
+    assert len(split_list) == 3
+    splits = {k: float(v) for k, v in zip(["train", "dev", "test"], split_list)}
+    assert sum(splits.values()) == 1.0
+
+    return splits
+
+
+def batched_func(iterable, chunk_size):
+    iterator = iter(iterable)
+    return list(iter(
+        lambda: list(islice(iterator, chunk_size)),
+        list()
+    ))
+
+
+def main():
+    args = get_args()
+
+    print("Script for creating a CoNLL format of my dataset from text files and Label Studio annotations. "
+          "Script goes through page text files and their annotations json record. "
+          "Output CoNLL dataset split files are saved to output directory.")
+
+    splits_ratios = parse_splits(args.split_ratios)
+
+    with open(args.source_file, encoding="utf-8") as f:
+        content = f.read()
+        annotations = content.split("\n\n")
+
+    print(f"Total training examples: {len(annotations)}\nStarting documents processing...")
+
+    if args.shuffle:
+        if args.shuffle_chunk > 1:
+            chunked_annotations = batched_func(annotations, args.shuffle_chunk)
+            shuffle(chunked_annotations)
+            annotations = [item for sublist in chunked_annotations for item in sublist]
+        else:
+            shuffle(annotations)
+
+    splits = {}
+    lower_bound = 0
+    for k, ratio in splits_ratios.items():
+        upper_bound = lower_bound + int(ratio * len(annotations))
+        splits[k] = annotations[lower_bound:upper_bound]
+        lower_bound = upper_bound
+
+    for name, split in splits.items():
+        with open(os.path.join(args.output_dir, "poner_" + name + ".conll"), "w", encoding="utf-8") as f:
+            for example in split:
+                f.write(example + "\n\n")
+
+        print(f"Split '{name}' is processed.")
+
+
+if __name__ == '__main__':
+    main()