unlfs

README.md

@@ -1,3 +1,75 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ff256045a63e274e175d197ff7906490586c679d410bd9e59cda6b12155a962e
-size 4054
+---
+annotations_creators:
+- expert-generated
+language_creators:
+- found
+languages:
+- en
+licenses:
+- cc-by-4.0
+multilinguality:
+- monolingual
+pretty_name: 'WIESP2022-NER'
+size_categories:
+- 1K<n<10K
+source_datasets: []
+task_categories:
+- token-classification
+task_ids:
+- named-entity-recognition
+---
+# Dataset for the first <a href="https://ui.adsabs.harvard.edu/WIESP/" style="color:blue">Workshop on Information Extraction from Scientific Publications (WIESP/2022)</a>.
+**(NOTE: loading from the Huggingface Dataset Hub directly does not work. You need to clone the repository locally.)**
+
+## Dataset Description
+Datasets with text fragments from astrophysics papers, provided by the [NASA Astrophysical Data System](https://ui.adsabs.harvard.edu/) with manually tagged astronomical facilities and other entities of interest (e.g., celestial objects).  
+Datasets are in JSON Lines format (each line is a json dictionary).  
+The datasets are formatted similarly to the CONLL2003 format. Each token is associated with an NER tag. The tags follow the "B-" and "I-" convention from the [IOB2 syntax]("https://en.wikipedia.org/wiki/Inside%E2%80%93outside%E2%80%93beginning_(tagging)")
+
+Each entry consists of a dictionary with the following keys:
+- `"unique_id"`: a unique identifier for this data sample. Must be included in the predictions.
+- `"tokens"`: the list of tokens (strings) that form the text of this sample. Must be included in the predictions.
+- `"ner_tags"`: the list of NER tags (in IOB2 format)
+
+The following keys are not strictly needed by the participants:
+- `"ner_ids"`: the pre-computed list of ids corresponding ner_tags, as given by the dictionary in ner_tags.json
+- `"label_studio_id"`, `"section"`, `"bibcode"`: references for internal NASA/ADS use.
+
+## Instructions for Workshop participants:
+How to load the data:  
+(assuming `./WIESP2022-NER-DEV.jsonl` is in the current directory, change as needed)
+- python (as list of dictionaries):
+```
+import json
+with open("./WIESP2022-NER-DEV.jsonl", 'r') as f:
+    wiesp_dev_json = [json.loads(l) for l in list(f)]
+```
+ - into Huggingface (as a Huggingface Dataset):
+```
+from datasets import Dataset
+wiesp_dev_from_json = Dataset.from_json(path_or_paths="./WIESP2022-NER-DEV.jsonl")
+```
+(NOTE: loading from the Huggingface Dataset Hub directly does not work. You need to clone the repository locally.)
+
+How to compute your scores on the training data:
+1. format your predictions as a list of dictionaries, each with the same `"unique_id"` and `"tokens"` keys from the dataset, as well as the list of predicted NER tags under the `"pred_ner_tags"` key (see `WIESP2022-NER-DEV-sample-predictions.jsonl` for an example).
+2. pass the references and predictions datasets to the `compute_MCC()` and `compute_seqeval()` functions (from the `.py` files with the same names).
+
+Requirement to run the scoring scripts:  
+[NumPy](https://numpy.org/install/)  
+[scikit-learn](https://scikit-learn.org/stable/install.html)  
+[seqeval](https://github.com/chakki-works/seqeval#installation)
+
+To get scores on the validation data, zip your predictions file (a single `.jsonl' file formatted following the same instructions as above) and upload the `.zip` file to the [Codalabs](https://codalab.lisn.upsaclay.fr/competitions/5062) competition.
+
+## File list
+```
+├── WIESP2022-NER-TRAINING.jsonl : 1753 samples for training.
+├── WIESP2022-NER-DEV.jsonl : 20 samples for development.
+├── WIESP2022-NER-DEV-sample-predictions.jsonl : an example file with properly formatted predictions on the development data.
+├── WIESP2022-NER-VALIDATION-NO-LABELS.jsonl : 1366 samples for validation without the NER labels. Used for the WIESP2022 workshop.
+├── README.MD: this file.
+└── scoring-scripts/ : scripts used to evaluate submissions.
+    ├── compute_MCC.py : computes the Matthews correlation coefficient between two datasets.
+    └── compute_seqeval.py : computes the seqeval scores (precision, recall, f1, overall and for each class) between two datasets.
+```

ner_tags.json

@@ -1,3 +1 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9fea87e4946d4916de22d1c78a13e4e444a8454ba4b4cca713137df25ad21c08
-size 1239
+{"B-Archive": 0, "B-CelestialObject": 1, "B-CelestialObjectRegion": 2, "B-CelestialRegion": 3, "B-Citation": 4, "B-Collaboration": 5, "B-ComputingFacility": 6, "B-Database": 7, "B-Dataset": 8, "B-EntityOfFutureInterest": 9, "B-Event": 10, "B-Fellowship": 11, "B-Formula": 12, "B-Grant": 13, "B-Identifier": 14, "B-Instrument": 15, "B-Location": 16, "B-Mission": 17, "B-Model": 18, "B-ObservationalTechniques": 19, "B-Observatory": 20, "B-Organization": 21, "B-Person": 22, "B-Proposal": 23, "B-Software": 24, "B-Survey": 25, "B-Tag": 26, "B-Telescope": 27, "B-TextGarbage": 28, "B-URL": 29, "B-Wavelength": 30, "I-Archive": 31, "I-CelestialObject": 32, "I-CelestialObjectRegion": 33, "I-CelestialRegion": 34, "I-Citation": 35, "I-Collaboration": 36, "I-ComputingFacility": 37, "I-Database": 38, "I-Dataset": 39, "I-EntityOfFutureInterest": 40, "I-Event": 41, "I-Fellowship": 42, "I-Formula": 43, "I-Grant": 44, "I-Identifier": 45, "I-Instrument": 46, "I-Location": 47, "I-Mission": 48, "I-Model": 49, "I-ObservationalTechniques": 50, "I-Observatory": 51, "I-Organization": 52, "I-Person": 53, "I-Proposal": 54, "I-Software": 55, "I-Survey": 56, "I-Tag": 57, "I-Telescope": 58, "I-TextGarbage": 59, "I-URL": 60, "I-Wavelength": 61, "O": 62}

scoring-scripts/compute_MCC.py

@@ -1,3 +1,31 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e1cb6528aa210c43f16718544dd0a4a731a10a504af73da9a7bc886c3493ac3c
-size 1368
+from sklearn.metrics import matthews_corrcoef
+import numpy as np
+def compute_MCC_jsonl(references_jsonl, predictions_jsonl, ref_col='ner_tags', pred_col='pred_ner_tags'):
+    '''
+    Computes the Matthews correlation coeff between two datasets in jsonl format (list of dicts each with same keys).
+    Sorts the datasets by 'unique_id' and verifies that the tokens match.
+    '''
+    # reverse the dict
+    ref_dict = {k:[e[k] for e in references_jsonl] for k in references_jsonl[0].keys()}
+    pred_dict = {k:[e[k] for e in predictions_jsonl] for k in predictions_jsonl[0].keys()}
+
+    # sort by unique_id
+    ref_idx = np.argsort(ref_dict['unique_id'])
+    pred_idx = np.argsort(pred_dict['unique_id'])
+    ref_ner_tags = np.array(ref_dict[ref_col], dtype=object)[ref_idx]
+    pred_ner_tags = np.array(pred_dict[pred_col], dtype=object)[pred_idx]
+    ref_tokens = np.array(ref_dict['tokens'], dtype=object)[ref_idx]
+    pred_tokens = np.array(pred_dict['tokens'], dtype=object)[pred_idx]
+
+    # check that tokens match
+    for t1,t2 in zip(ref_tokens, pred_tokens):
+        assert(t1==t2)
+
+    # the lists have to be flattened
+    flat_ref_tags = np.concatenate(ref_ner_tags)
+    flat_pred_tags = np.concatenate(pred_ner_tags)
+
+    mcc_score = matthews_corrcoef(y_true=flat_ref_tags,
+                                  y_pred=flat_pred_tags)
+    
+    return(mcc_score)

scoring-scripts/compute_seqeval.py

@@ -1,3 +1,49 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a36bebf01df4893bd7e901dce1a74192d53e7fcdf3e9be7e788783c00a356dbb
-size 2128
+from seqeval.metrics import classification_report, f1_score, precision_score, recall_score, accuracy_score
+from seqeval.scheme import IOB2
+import numpy as np
+def compute_seqeval_jsonl(references_jsonl, predictions_jsonl, ref_col='ner_tags', pred_col='pred_ner_tags'):
+    '''
+    Computes the seqeval scores between two datasets loaded from jsonl (list of dicts with same keys).
+    Sorts the datasets by 'unique_id' and verifies that the tokens match.
+    '''
+    # extract the tags and reverse the dict
+    ref_dict = {k:[e[k] for e in references_jsonl] for k in references_jsonl[0].keys()}
+    pred_dict = {k:[e[k] for e in predictions_jsonl] for k in predictions_jsonl[0].keys()}
+        
+    # sort by unique_id
+    ref_idx = np.argsort(ref_dict['unique_id'])
+    pred_idx = np.argsort(pred_dict['unique_id'])
+    ref_ner_tags = np.array(ref_dict[ref_col], dtype=object)[ref_idx]
+    pred_ner_tags = np.array(pred_dict[pred_col], dtype=object)[pred_idx]
+    ref_tokens = np.array(ref_dict['tokens'], dtype=object)[ref_idx]
+    pred_tokens = np.array(pred_dict['tokens'], dtype=object)[pred_idx]
+
+    # check that tokens match
+    assert((ref_tokens==pred_tokens).all())
+    
+    
+    # get report
+    report = classification_report(y_true=ref_ner_tags, y_pred=pred_ner_tags, 
+                                   scheme=IOB2, output_dict=True,
+                                  )
+    
+    # extract values we care about
+    report.pop("macro avg")
+    report.pop("weighted avg")
+    overall_score = report.pop("micro avg")
+
+    seqeval_results = {
+        type_name: {
+            "precision": score["precision"],
+            "recall": score["recall"],
+            "f1": score["f1-score"],
+            "suport": score["support"],
+        }
+        for type_name, score in report.items()
+    }
+    seqeval_results["overall_precision"] = overall_score["precision"]
+    seqeval_results["overall_recall"] = overall_score["recall"]
+    seqeval_results["overall_f1"] = overall_score["f1-score"]
+    seqeval_results["overall_accuracy"] = accuracy_score(y_true=ref_ner_tags, y_pred=pred_ner_tags)    
+    
+    return(seqeval_results)