Update parquet files

.gitattributes

@@ -1,51 +0,0 @@
-*.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
-*.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
-*.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
-saved_model/**/* 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

README.md

@@ -1,109 +0,0 @@
----
-annotations_creators:
-- expert-generated
-language_creators:
-- found
-language:
-- sl
-license:
-- cc-by-nc-sa-4.0
-multilinguality:
-- monolingual
-size_categories:
-- 1K<n<10K
-source_datasets: []
-task_categories:
-- token-classification
-task_ids: []
-pretty_name: G-KOMET
-tags:
-- metaphor-classification
-- metonymy-classification
-- metaphor-frame-classification
-- multiword-expression-detection
----
-
-# Dataset Card for G-KOMET
-
-### Dataset Summary
-
-G-KOMET 1.0 is a corpus of metaphorical expressions in spoken Slovene language, covering around 50,000 lexical units across 5695 sentences. The corpus contains samples from the Gos corpus of spoken Slovene and includes a balanced set of transcriptions of informative, educational, entertaining, private, and public discourse.
-
-It is also annotated with idioms and metonymies. Note that these are both annotated as metaphor types. This is different from the annotations in [KOMET](https://huggingface.co/datasets/cjvt/komet), where these are both considered a type of frame. We keep the data as untouched as possible and let the user decide how they want to handle this. 
-
-
-### Supported Tasks and Leaderboards
-
-Metaphor detection, metonymy detection, metaphor type classification, metaphor frame classification. 
-
-### Languages
-
-Slovenian.
-
-## Dataset Structure
-
-### Data Instances
-
-A sample instance from the dataset:
-```
-{
-  'document_name': 'G-Komet001.xml', 
-  'idx': 3, 
-  'idx_paragraph': 0, 
-  'idx_sentence': 3, 
-  'sentence_words': ['no', 'zdaj', 'samo', 'še', 'za', 'eno', 'orientacijo'], 
-  'met_type': [
-    {'type': 'MRWi', 'word_indices': [6]}
-  ], 
-  'met_frame': [
-    {'type': 'spatial_orientation', 'word_indices': [6]}
-  ]
-}
-```
-
-The sentence comes from the document `G-Komet001.xml`, is the 3rd sentence in the document and is the 3rd sentence inside the 0th paragraph in the document.
-The word "orientacijo" is annotated as an indirect metaphor-related word (`MRWi`).
-It is also annotated with the frame "spatial_orientation".
-
-### Data Fields
-
-- `document_name`: a string containing the name of the document in which the sentence appears; 
-- `idx`: a uint32 containing the index of the sentence inside its document; 
-- `idx_paragraph`: a uint32 containing the index of the paragraph in which the sentence appears;
-- `idx_sentence`: a uint32 containing the index of the sentence inside its paragraph;
-containing the consecutive number of the paragraph inside the current news article;
-- `sentence_words`: words in the sentence;
-- `met_type`: metaphors in the sentence, marked by their type and word indices;
-- `met_frame`: metaphor frames in the sentence, marked by their type (frame name) and word indices.
-
-## Dataset Creation
-
-The corpus contains samples from the GOS corpus of spoken Slovene and includes a balanced set of transcriptions of informative, educational, entertaining, private, and public discourse. It contains hand-annotated metaphor-related words, i.e. linguistic expressions that have the potential for people to interpret them as metaphors, idioms, i.e. multi-word units in which at least one word has been used metaphorically, and metonymies, expressions that we use to express something else.
-
-For more information, please check out the paper (which is in Slovenian language) or contact the dataset author.
-
-## Additional Information
-
-### Dataset Curators
-
-Špela Antloga.
-
-### Licensing Information
-
-CC BY-NC-SA 4.0
-
-### Citation Information
-
-```
-@InProceedings{antloga2022gkomet,
-title = {Korpusni pristopi za identifikacijo metafore in metonimije: primer metonimije v korpusu gKOMET},
-author={Antloga, \v{S}pela},
-booktitle={Proceedings of the Conference on Language Technologies and Digital Humanities (Student papers)},
-year={2022},
-pages={271-277}
-}
-```
-
-### Contributions
-
-Thanks to [@matejklemen](https://github.com/matejklemen) for adding this dataset.

dataset_infos.json

@@ -1 +0,0 @@
-{"default": {"description": "G-KOMET 1.0 (a corpus of metaphorical expressions in spoken Slovene language) is a corpus of speech transcriptions and \nconversations that covers 50,000 lexical units. The corpus contains samples from the Gos corpus of spoken Slovene \nand includes a balanced set of transcriptions of informative, educational, entertaining, private, and public discourse.\n\nThe annotation scheme was based on the MIPVU metaphor identification process. \nThis protocol was modified and adapted to the specifics of the Slovene language and the specifics of the spoken \nlanguage. Corpus was annotated for the following relations to metaphor: indirect metaphor, direct metaphor, borderline \ncases and metaphor signals. In addition, the corpus introduces a new \u2018frame\u2019 tag, which gives information about the \nconcept to which it refers. \n", "citation": "@InProceedings{antloga2022gkomet,\ntitle = {Korpusni pristopi za identifikacijo metafore in metonimije: primer metonimije v korpusu gKOMET},\nauthor={Antloga, \u000b{S}pela},\nbooktitle={Proceedings of the Conference on Language Technologies and Digital Humanities (Student papers)},\nyear={2022},\npages={271-277}\n}\n", "homepage": "http://hdl.handle.net/11356/1490", "license": "Creative Commons - Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0)", "features": {"document_name": {"dtype": "string", "id": null, "_type": "Value"}, "idx": {"dtype": "uint32", "id": null, "_type": "Value"}, "idx_paragraph": {"dtype": "uint32", "id": null, "_type": "Value"}, "idx_sentence": {"dtype": "uint32", "id": null, "_type": "Value"}, "sentence_words": {"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"}}], "met_frame": [{"type": {"dtype": "string", "id": null, "_type": "Value"}, "word_indices": {"feature": {"dtype": "uint32", "id": null, "_type": "Value"}, "length": -1, "id": null, "_type": "Sequence"}}]}, "post_processed": null, "supervised_keys": null, "task_templates": null, "builder_name": "gkomet", "config_name": "default", "version": {"version_str": "1.0.0", "description": null, "major": 1, "minor": 0, "patch": 0}, "splits": {"train": {"name": "train", "num_bytes": 736441, "num_examples": 5695, "dataset_name": "gkomet"}}, "download_checksums": {"https://www.clarin.si/repository/xmlui/bitstream/handle/11356/1490/G-Komet.zip": {"num_bytes": 1005891, "checksum": "29fffdaf085b889926eedcd9673f2129513b4578f41ba9bf7c632fe50cd45a8f"}}, "download_size": 1005891, "post_processing_size": null, "dataset_size": 736441, "size_in_bytes": 1742332}}

default/gkomet-train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56e18e9d8efaee60d7903ea136568fea06300475eae6237d3148c617b488a686
+size 234721

gkomet.py

@@ -1,288 +0,0 @@
-"""Metaphor corpus G-KOMET 1.0"""
-import logging
-import os
-import re
-import xml.etree.ElementTree as ET
-from typing import List, Tuple
-
-import datasets
-
-_CITATION = """\
-@InProceedings{antloga2022gkomet,
-title = {Korpusni pristopi za identifikacijo metafore in metonimije: primer metonimije v korpusu gKOMET},
-author={Antloga, \v{S}pela},
-booktitle={Proceedings of the Conference on Language Technologies and Digital Humanities (Student papers)},
-year={2022},
-pages={271-277}
-}
-"""
-
-
-_DESCRIPTION = """\
-G-KOMET 1.0 (a corpus of metaphorical expressions in spoken Slovene language) is a corpus of speech transcriptions and 
-conversations that covers 50,000 lexical units. The corpus contains samples from the Gos corpus of spoken Slovene 
-and includes a balanced set of transcriptions of informative, educational, entertaining, private, and public discourse.
-
-The annotation scheme was based on the MIPVU metaphor identification process. 
-This protocol was modified and adapted to the specifics of the Slovene language and the specifics of the spoken 
-language. Corpus was annotated for the following relations to metaphor: indirect metaphor, direct metaphor, borderline 
-cases and metaphor signals. In addition, the corpus introduces a new ‘frame’ tag, which gives information about the 
-concept to which it refers. 
-"""
-
-_HOMEPAGE = "http://hdl.handle.net/11356/1490"
-
-_LICENSE = "Creative Commons - Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0)"
-
-_URLS = {
-    "gkomet": "https://www.clarin.si/repository/xmlui/bitstream/handle/11356/1490/G-Komet.zip"
-}
-
-
-XML_NAMESPACE = "{http://www.w3.org/XML/1998/namespace}"
-EL_LEAF, EL_TYPE, EL_FRAME = range(3)
-
-
-def namespace(element):
-    # https://stackoverflow.com/a/12946675
-    m = re.match(r'\{.*\}', element.tag)
-    return m.group(0) if m else ''
-
-
-def word_info(sent_el):
-    def _resolve_recursively(element) -> List:
-        """ Knowingly ignored tags: name (anonymized, without IDs), gap, vocal, pause, del,
-        linkGrp (handled separately in linkgroup_info()) """
-        # Leaf node: word or punctuation character
-        if element.tag.endswith(("w", "pc")):
-            id_curr = element.attrib[f"{XML_NAMESPACE}id"]
-            return [(id_curr, element.text)]
-
-        # Annotated word or word group - not interested in the annotations in this function
-        elif element.tag.endswith("seg"):
-            parsed_data = []
-            for child in element:
-                if child.tag.endswith(("c", "vocal", "pause")) and not child.tag.endswith("pc"):  # empty space betw. words or "special" word
-                    continue
-
-                res = _resolve_recursively(child)
-                if isinstance(res, list):
-                    parsed_data.extend(res)
-                else:
-                    parsed_data.append(res)
-
-            return parsed_data
-
-    id_words, words = [], []
-    for child_el in sent_el:
-        curr_annotations = _resolve_recursively(child_el)
-        if curr_annotations is not None:  # None = unrecognized ("unimportant") element
-            for ann in curr_annotations:
-                id_words.append(ann[0])
-                words.append(ann[1])
-
-    return id_words, words
-
-
-def seg_info(sent_el):
-    def _resolve_recursively(element) -> Tuple:
-        """ Returns (type[, subtype], deeper_elements, latest_element)"""
-        # Leaf node: word or punctuation character
-        if element.tag.endswith(("w", "pc")):
-            id_curr = element.attrib[f"{XML_NAMESPACE}id"]
-            return EL_LEAF, [], [id_curr]
-
-        # Annotated word or word group
-        elif element.tag.endswith("seg"):
-            subtype = element.attrib["subtype"]
-            if element.attrib["type"] == "frame":
-                ann_type = EL_FRAME
-            elif element.attrib["type"] == "metaphor":
-                ann_type = EL_TYPE
-            elif element.attrib["type"] == "idiom":
-                ann_type = EL_TYPE
-            else:
-                raise ValueError(f"Unrecognized seg type: {element.attrib['type']}")
-
-            deeper_elements = []
-            latest_element = []
-            for child in element:
-                if child.tag.endswith(("c", "vocal", "pause")) and not child.tag.endswith("pc"):  # empty space betw. words or "special" word
-                    continue
-
-                res = _resolve_recursively(child)
-                if res[0] == EL_LEAF:
-                    latest_element.extend(res[2])
-                else:
-                    deeper_elements.extend(res[2])
-                    deeper_elements.append((res[0], res[1], res[3]))
-                    latest_element.extend(res[3])
-
-            return ann_type, subtype, deeper_elements, latest_element
-
-    annotations = []
-    for child_el in sent_el:
-        if not child_el.tag.endswith("seg"):
-            continue
-
-        ann_type, subtype, deeper_elements, latest_element = _resolve_recursively(child_el)
-        annotations.extend(deeper_elements)
-        annotations.append((ann_type, subtype, latest_element))
-
-    return annotations
-
-
-def linkgroup_info(sent_el):
-    annotations = []
-    for child_el in sent_el:
-        if not child_el.tag.endswith("linkGrp"):
-            continue
-
-        for curr_link in child_el:
-            ann_type = EL_TYPE
-            if child_el.attrib["type"] not in {"metonymy", "frame", "metaphor", "idiom"}:
-                logging.warning(f"Uncovered linkGrp element type, skipping: {child_el.attrib['type']}")
-                continue
-
-            if child_el.attrib["type"] == "metonymy":
-                subtype = curr_link.attrib["ana"]
-            elif child_el.attrib["type"] in {"frame", "metaphor"}:
-                ann_type = EL_TYPE if child_el.attrib["type"] == "metaphor" else EL_FRAME
-                subtype = curr_link.attrib["ana"].split(":")[-1]
-            else:
-                subtype = "idiom"
-
-            tokens_involved = list(map(lambda _tok_id: _tok_id[1:] if _tok_id.startswith("#") else _tok_id,
-                                       curr_link.attrib["target"].split(" ")))
-            annotations.append((ann_type, subtype, tokens_involved))
-
-    return annotations
-
-
-class GKomet(datasets.GeneratorBasedBuilder):
-    """G-KOMET 1.0 is a corpus of metaphorical expressions in spoken Slovene language. """
-
-    VERSION = datasets.Version("1.0.0")
-
-    def _info(self):
-        features = datasets.Features(
-            {
-                "document_name": datasets.Value("string"),
-                "idx": datasets.Value("uint32"),  # index inside current document
-                "idx_paragraph": datasets.Value("uint32"),
-                "idx_sentence": datasets.Value("uint32"),  # index inside current paragraph
-                "sentence_words": datasets.Sequence(datasets.Value("string")),
-                "met_type": [{
-                    "type": datasets.Value("string"),
-                    "word_indices": datasets.Sequence(datasets.Value("uint32"))
-                }],
-                "met_frame": [{
-                    "type": datasets.Value("string"),
-                    "word_indices": datasets.Sequence(datasets.Value("uint32"))
-                }]
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            homepage=_HOMEPAGE,
-            license=_LICENSE,
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        data_dir = dl_manager.download_and_extract(_URLS["gkomet"])
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={"data_dir": os.path.join(data_dir, "G-Komet")},
-            )
-        ]
-
-    def _generate_examples(self, data_dir):
-        data_files = []
-        for fname in os.listdir(data_dir):
-            curr_path = os.path.join(data_dir, fname)
-            if os.path.isfile(curr_path) and fname.endswith(".xml") and fname != "G-Komet.xml":  # G-Komet.xml = meta-file
-                data_files.append(fname)
-        data_files = sorted(data_files)
-
-        idx_example = 0
-        for fname in data_files:
-            fpath = os.path.join(data_dir, fname)
-            curr_doc = ET.parse(fpath)
-            root = curr_doc.getroot()
-            NAMESPACE = namespace(root)
-
-            idx_sent_glob = 0
-            for idx_par, curr_par in enumerate(root.iterfind(f".//{NAMESPACE}p")):
-                id2position = {}  # {<idx_sent> -> {<id_word>: <position> foreach word} foreach sent}
-                all_words = []
-
-                # Pass#1: extract word information
-                for idx_sent, curr_sent in enumerate(curr_par.iterfind(f"{NAMESPACE}s")):
-                    id_words, words = word_info(curr_sent)
-
-                    id2position[idx_sent] = dict(zip(id_words, range(len(words))))
-                    all_words.append(words)
-
-                all_types, all_frames = [], []
-
-                # Pass#2: extract annotations from <seg>ments
-                for idx_sent, curr_sent in enumerate(curr_par.iterfind(f"{NAMESPACE}s")):
-                    annotated_segs = seg_info(curr_sent)
-                    all_types.append([])
-                    all_frames.append([])
-
-                    for curr_ann in annotated_segs:
-                        ann_type, ann_subtype, words_involved = curr_ann
-                        if ann_type == EL_TYPE:
-                            all_types[idx_sent].append({
-                                "type": ann_subtype,
-                                "word_indices": [id2position[idx_sent][_id_word] for _id_word in words_involved
-                                                 if _id_word in id2position[idx_sent]]
-                            })
-                        elif ann_type == EL_FRAME:
-                            all_frames[idx_sent].append({
-                                "type": ann_subtype,
-                                "word_indices": [id2position[idx_sent][_id_word] for _id_word in words_involved
-                                                 if _id_word in id2position[idx_sent]]
-                            })
-
-                # Pass#3: extract annotations from <linkGrp>s
-                for idx_sent, curr_sent in enumerate(curr_par.iterfind(f"{NAMESPACE}s")):
-                    annotated_linkgroups = linkgroup_info(curr_sent)
-
-                    for curr_ann in annotated_linkgroups:
-                        ann_type, ann_subtype, words_involved = curr_ann
-
-                        if ann_type == EL_TYPE:
-                            all_types[idx_sent].append({
-                                "type": ann_subtype,
-                                "word_indices": [id2position[idx_sent][_id_word] for _id_word in words_involved
-                                                 if _id_word in id2position[idx_sent]]
-                            })
-                        elif ann_type == EL_FRAME:
-                            all_frames[idx_sent].append({
-                                "type": ann_subtype,
-                                "word_indices": [id2position[idx_sent][_id_word] for _id_word in words_involved
-                                                 if _id_word in id2position[idx_sent]]
-                            })
-
-                idx_sent = 0
-                for curr_words, curr_types, curr_frames in zip(all_words, all_types, all_frames):
-                    if len(curr_words) == 0:
-                        continue
-
-                    yield idx_example, {
-                        "document_name": fname,
-                        "idx": idx_sent_glob,
-                        "idx_paragraph": idx_par,
-                        "idx_sentence": idx_sent,
-                        "sentence_words": curr_words,
-                        "met_type": curr_types,
-                        "met_frame": curr_frames
-                    }
-                    idx_example += 1
-                    idx_sent += 1
-                    idx_sent_glob += 1