Add first version of VUAMC

dataset_infos.json

@@ -0,0 +1 @@
+{"default": {"description": "The resource contains a selection of excerpts from BNC-Baby files that have been annotated for metaphor. \nThere are four registers, each comprising about 50,000 words: academic texts, news texts, fiction, and conversations. \nWords have been separately labelled as participating in multi-word expressions (about 1.5%) or as discarded for \nmetaphor analysis (0.02%). Main categories include words that are related to metaphor (MRW), words that signal \nmetaphor (MFlag), and words that are not related to metaphor. For metaphor-related words, subdivisions have been made \nbetween clear cases of metaphor versus borderline cases (WIDLII, When In Doubt, Leave It In). Another parameter of \nmetaphor-related words makes a distinction between direct metaphor, indirect metaphor, and implicit metaphor.\n", "citation": "@book{steen2010method,\n  title={A method for linguistic metaphor identification: From MIP to MIPVU},\n  author={Steen, Gerard and Dorst, Lettie and Herrmann, J. and Kaal, Anna and Krennmayr, Tina and Pasma, Trijntje},\n  volume={14},\n  year={2010},\n  publisher={John Benjamins Publishing}\n}\n", "homepage": "https://hdl.handle.net/20.500.12024/2541", "license": "Available for non-commercial use on condition that the terms of the BNC Licence are observed and that this header is included in its entirety with any copy distributed.", "features": {"document_name": {"dtype": "string", "id": null, "_type": "Value"}, "words": {"feature": {"dtype": "string", "id": null, "_type": "Value"}, "length": -1, "id": null, "_type": "Sequence"}, "lemmas": {"feature": {"dtype": "string", "id": null, "_type": "Value"}, "length": -1, "id": null, "_type": "Sequence"}, "pos_tags": {"feature": {"dtype": "string", "id": null, "_type": "Value"}, "length": -1, "id": null, "_type": "Sequence"}, "met_type": [{"type": {"dtype": "string", "id": null, "_type": "Value"}, "word_indices": {"feature": {"dtype": "uint32", "id": null, "_type": "Value"}, "length": -1, "id": null, "_type": "Sequence"}}], "meta": {"feature": {"dtype": "string", "id": null, "_type": "Value"}, "length": -1, "id": null, "_type": "Sequence"}}, "post_processed": null, "supervised_keys": null, "task_templates": null, "builder_name": "vuamc", "config_name": "default", "version": {"version_str": "1.0.0", "description": null, "major": 1, "minor": 0, "patch": 0}, "splits": {"train": {"name": "train", "num_bytes": 8512176, "num_examples": 16740, "dataset_name": "vuamc"}}, "download_checksums": {"https://ota.bodleian.ox.ac.uk/repository/xmlui/bitstream/handle/20.500.12024/2541/VUAMC.xml": {"num_bytes": 16820946, "checksum": "0ac1a77cc1879aa0c87e2879481d0e1e3f28e36b1701893c096a33ff11aa6e0d"}}, "download_size": 16820946, "post_processing_size": null, "dataset_size": 8512176, "size_in_bytes": 25333122}}

vuamc.py

@@ -0,0 +1,351 @@
+""" English metaphor-annotated corpus. """
+
+import os
+
+import datasets
+import logging
+import re
+
+import xml.etree.ElementTree as ET
+from typing import List, Tuple, Dict
+
+
+_CITATION = """\
+@book{steen2010method,
+  title={A method for linguistic metaphor identification: From MIP to MIPVU},
+  author={Steen, Gerard and Dorst, Lettie and Herrmann, J. and Kaal, Anna and Krennmayr, Tina and Pasma, Trijntje},
+  volume={14},
+  year={2010},
+  publisher={John Benjamins Publishing}
+}
+"""
+
+_DESCRIPTION = """\
+The resource contains a selection of excerpts from BNC-Baby files that have been annotated for metaphor. 
+There are four registers, each comprising about 50,000 words: academic texts, news texts, fiction, and conversations. 
+Words have been separately labelled as participating in multi-word expressions (about 1.5%) or as discarded for 
+metaphor analysis (0.02%). Main categories include words that are related to metaphor (MRW), words that signal 
+metaphor (MFlag), and words that are not related to metaphor. For metaphor-related words, subdivisions have been made 
+between clear cases of metaphor versus borderline cases (WIDLII, When In Doubt, Leave It In). Another parameter of 
+metaphor-related words makes a distinction between direct metaphor, indirect metaphor, and implicit metaphor.
+"""
+
+_HOMEPAGE = "https://hdl.handle.net/20.500.12024/2541"
+
+_LICENSE = "Available for non-commercial use on condition that the terms of the BNC Licence are observed and that " \
+           "this header is included in its entirety with any copy distributed."
+
+_URLS = {
+    "vuamc": "https://ota.bodleian.ox.ac.uk/repository/xmlui/bitstream/handle/20.500.12024/2541/VUAMC.xml"
+}
+
+
+XML_NAMESPACE = "{http://www.w3.org/XML/1998/namespace}"
+VICI_NAMESPACE = "{http://www.tei-c.org/ns/VICI}"
+NA_STR = "N/A"
+
+
+def namespace(element):
+    # https://stackoverflow.com/a/12946675
+    m = re.match(r'\{.*\}', element.tag)
+    return m.group(0) if m else ''
+
+
+def resolve_recursively(el, ns):
+    words, lemmas, pos_tags, met_type, meta_tags = [], [], [], [], []
+
+    if el.tag.endswith("w"):
+        # A <w>ord may be
+        #   (1) just text,
+        #   (2) a metaphor (text fully enclosed in another seg)
+        #   (3) a partial metaphor (optionally some text, followed by a seg, optionally followed by more text)
+        idx_word = 0
+        _w_text = el.text.strip() if el.text is not None else ""
+        if len(_w_text) > 0:
+            words.append(_w_text)
+            lemmas.append(_w_text)
+            pos_tags.append(el.attrib["type"])
+            meta_tags.append(NA_STR)
+            idx_word += 1
+
+        met_els = el.findall(f"{ns}seg")
+        for met_el in met_els:
+            parse_tail = True
+            if met_el.text is None:
+                # Handle encoding inconsistency where the metaphor is encoded without a closing tag (I hate this format)
+                # <w lemma="to" type="PRP"><seg function="mrw" type="met" vici:morph="n"/>to </w>
+                parse_tail = False
+                _w_text = met_el.tail.strip()
+            else:
+                _w_text = met_el.text.strip()
+
+            curr_met_type = met_el.attrib[f"function"]
+
+            # Let the user decide how they want to aggregate metaphors
+            if "type" in met_el.attrib:
+                curr_met_type = f"{curr_met_type}/{met_el.attrib['type']}"
+
+            if "subtype" in met_el.attrib:
+                curr_met_type = f"{curr_met_type}/{met_el.attrib['subtype']}"
+
+            words.append(_w_text)
+            lemmas.append(_w_text)
+            pos_tags.append(el.attrib["type"])
+            meta_tags.append(NA_STR)
+            met_type.append({"type": curr_met_type, "word_indices": [idx_word]})
+            idx_word += 1
+
+            if not parse_tail:
+                continue
+
+            _w_text = met_el.tail.strip() if met_el.tail is not None else ""
+            if len(_w_text) > 0:
+                words.append(_w_text)
+                lemmas.append(_w_text)
+                pos_tags.append(el.attrib["type"])
+                meta_tags.append(NA_STR)
+                idx_word += 1
+
+    elif el.tag.endswith("vocal"):
+        desc_el = el.find(f"{ns}desc")
+        description = desc_el.text.strip() if desc_el is not None else "unknown"
+
+        words.append("")
+        lemmas.append("")
+        pos_tags.append(NA_STR)
+        meta_tags.append(f"vocal/{description}")  # vocal/<desc>
+
+    elif el.tag.endswith("gap"):
+        words.append("")
+        lemmas.append("")
+        pos_tags.append(NA_STR)
+        meta_tags.append(f"gap/{el.attrib.get('reason', 'unclear')}")  # gap/<reason>
+
+    elif el.tag.endswith("incident"):
+        desc_el = el.find(f"{ns}desc")
+        description = desc_el.text.strip() if desc_el is not None else "unknown"
+
+        words.append("")
+        lemmas.append("")
+        pos_tags.append(NA_STR)
+        meta_tags.append(f"incident/{description}")
+
+    elif el.tag.endswith("shift"):
+        # TODO: this is not exposed
+        new_state = el.attrib.get("new", "normal")
+        children = list(iter(el))
+        # NOTE: Intentionally skip shifts like this, without children:
+        # <u who="#PS05E"> <shift new="crying"/> </u>
+        if len(children) > 0:
+            for w_el in el:
+                _words, _lemmas, _pos, _mets, _metas = resolve_recursively(w_el, ns=ns)
+                words.extend(_words)
+                lemmas.extend(_lemmas)
+                pos_tags.extend(_pos)
+                meta_tags.extend(_metas)
+
+    elif el.tag.endswith("seg"):
+        # Direct <seg> descendant of a sentence indicates truncated text
+        word_el = el.find(f"{ns}w")
+
+        words.append(word_el.text.strip())
+        lemmas.append(word_el.attrib["lemma"])
+        pos_tags.append(word_el.attrib["type"])
+        meta_tags.append(NA_STR)
+
+    elif el.tag.endswith("pause"):
+        words.append("")
+        lemmas.append("")
+        pos_tags.append(NA_STR)
+        meta_tags.append(f"pause")
+
+    elif el.tag.endswith("sic"):
+        for w_el in el:
+            _words, _lemmas, _pos, _mets, _metas = resolve_recursively(w_el, ns=ns)
+            words.extend(_words)
+            lemmas.extend(_lemmas)
+            pos_tags.extend(_pos)
+            meta_tags.extend(_metas)
+
+    elif el.tag.endswith("c"):
+        words.append(el.text.strip())
+        lemmas.append(el.text.strip())
+        pos_tags.append(el.attrib["type"])
+        meta_tags.append(NA_STR)
+
+    elif el.tag.endswith("pb"):
+        words.append("")
+        lemmas.append("")
+        pos_tags.append(NA_STR)
+        meta_tags.append(NA_STR)
+
+    elif el.tag.endswith("hi"):
+        # TODO: this is not exposed
+        rendition = el.attrib.get("rend", "normal")
+
+        for child_el in el:
+            _words, _lemmas, _pos, _mets, _metas = resolve_recursively(child_el, ns=ns)
+            words.extend(_words)
+            lemmas.extend(_lemmas)
+            pos_tags.extend(_pos)
+            meta_tags.extend(_metas)
+
+    elif el.tag.endswith("choice"):
+        sic_el = el.find(f"{ns}sic")
+        _words, _lemmas, _pos, _mets, _metas = resolve_recursively(sic_el, ns=ns)
+        words.extend(_words)
+        lemmas.extend(_lemmas)
+        pos_tags.extend(_pos)
+        met_type.extend(_mets)
+        meta_tags.extend(_metas)
+
+    elif el.tag.endswith(("ptr", "corr")):
+        # Intentionally skipping these:
+        # - no idea what <ptr> is
+        # - <sic> is being parsed instead of <corr>
+        pass
+
+    else:
+        logging.warning(f"Unrecognized child element: {el.tag}.\n"
+                        f"If you are seeing this message, please open an issue on HF datasets.")
+
+    return words, lemmas, pos_tags, met_type, meta_tags
+
+
+def parse_sent(sent_el, ns) -> Tuple[List[str], List[str], List[str], List[Dict], List[str]]:
+    all_words, all_lemmas, all_pos_tags, all_met_types, all_metas = [], [], [], [], []
+    for child_el in sent_el:
+        word, lemma, pos, mtype, meta = resolve_recursively(child_el, ns=ns)
+        # Need to remap local (index inside the word group) `word_indices` to global (index inside the sentence)
+        if len(mtype) > 0:
+            base = len(all_words)
+            mtype = list(map(lambda met_info: {
+                "type": met_info["type"],
+                "word_indices": list(map(lambda _i: base + _i, met_info["word_indices"]))
+            }, mtype))
+
+        all_words.extend(word)
+        all_lemmas.extend(lemma)
+        all_pos_tags.extend(pos)
+        all_met_types.extend(mtype)
+        all_metas.extend(meta)
+
+    return all_words, all_lemmas, all_pos_tags, all_met_types, all_metas
+
+
+def parse_text_body(body_el, ns):
+    all_words: List[List] = []
+    all_lemmas: List[List] = []
+    all_pos: List[List] = []
+    all_met_type: List[List] = []
+    all_meta: List[List] = []
+
+    # Edge case#1: <s>entence
+    if body_el.tag.endswith("s"):
+        words, lemmas, pos_tags, met_types, meta_tags = parse_sent(body_el, ns=ns)
+        all_words.append(words)
+        all_lemmas.append(lemmas)
+        all_pos.append(pos_tags)
+        all_met_type.append(met_types)
+        all_meta.append(meta_tags)
+
+    # Edge case#2: <u>tterance either contains a sentence of metadata or contains multiple sentences as children
+    elif body_el.tag.endswith("u"):
+        children = list(filter(lambda _child: not _child.tag.endswith("ptr"), list(iter(body_el))))
+        is_utterance_sent = all(map(lambda _child: not _child.tag.endswith("s"), children))
+        if is_utterance_sent:
+            # <u> contains elements as children that are not a <s>entence, so it is itself considered a sentence
+            words, lemmas, pos_tags, met_types, meta_tags = parse_sent(body_el, ns=ns)
+            all_words.append(words)
+            all_lemmas.append(lemmas)
+            all_pos.append(pos_tags)
+            all_met_type.append(met_types)
+            all_meta.append(meta_tags)
+        else:
+            # <u> contains one or more of <s>entence children
+            for _child in children:
+                words, lemmas, pos_tags, met_types, meta_tags = parse_sent(_child, ns=ns)
+                all_words.append(words)
+                all_lemmas.append(lemmas)
+                all_pos.append(pos_tags)
+                all_met_type.append(met_types)
+                all_meta.append(meta_tags)
+
+    # Recursively go deeper through all the <p>aragraphs, <div>s, etc. until we reach the sentences
+    else:
+        for _child in body_el:
+            _c_word, _c_lemmas, _c_pos, _c_met, _c_meta = parse_text_body(_child, ns=ns)
+
+            all_words.extend(_c_word)
+            all_lemmas.extend(_c_lemmas)
+            all_pos.extend(_c_pos)
+            all_met_type.extend(_c_met)
+            all_meta.extend(_c_meta)
+
+    return all_words, all_lemmas, all_pos, all_met_type, all_meta
+
+
+class VUAMC(datasets.GeneratorBasedBuilder):
+    """English metaphor-annotated corpus. """
+
+    VERSION = datasets.Version("1.0.0")
+
+    def _info(self):
+        features = datasets.Features(
+            {
+                "document_name": datasets.Value("string"),
+                "words": datasets.Sequence(datasets.Value("string")),
+                "lemmas": datasets.Sequence(datasets.Value("string")),
+                "pos_tags": datasets.Sequence(datasets.Value("string")),
+                "met_type": [{
+                    "type": datasets.Value("string"),
+                    "word_indices": datasets.Sequence(datasets.Value("uint32"))
+                }],
+                "meta": datasets.Sequence(datasets.Value("string"))
+            }
+        )
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION
+        )
+
+    def _split_generators(self, dl_manager):
+        urls = _URLS["vuamc"]
+        data_path = dl_manager.download_and_extract(urls)
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={"file_path": os.path.join(data_path)}
+            )
+        ]
+
+    def _generate_examples(self, file_path):
+        curr_doc = ET.parse(file_path)
+        root = curr_doc.getroot()
+        NAMESPACE = namespace(root)
+        root = root.find(f"{NAMESPACE}text")
+
+        idx_instance = 0
+        for idx_doc, doc in enumerate(root.iterfind(f".//{NAMESPACE}text")):
+            document_name = doc.attrib[f"{XML_NAMESPACE}id"]
+            body = doc.find(f"{NAMESPACE}body")
+            body_data = parse_text_body(body, ns=NAMESPACE)
+
+            for sent_words, sent_lemmas, sent_pos, sent_met_type, sent_meta in zip(*body_data):
+                # TODO: Due to some simplifications (not parsing certain metadata), some sentences may be empty
+                if len(sent_words) == 0:
+                    continue
+
+                yield idx_instance, {
+                    "document_name": document_name,
+                    "words": sent_words,
+                    "lemmas": sent_lemmas,
+                    "pos_tags": sent_pos,
+                    "met_type": sent_met_type,
+                    "meta": sent_meta
+                }
+                idx_instance += 1