Add dataset loading script

README.md

@@ -1,3 +1,93 @@
 ---
-license: mit
+annotations_creators:
+- machine-generated
+language_creators:
+- found
+language:
+- en
+license:
+- mit
+multilinguality:
+- monolingual
+size_categories:
+- 10K<n<100K
+source_datasets:
+- original
+task_categories:
+- text-classification
+- sentence-similarity
+task_ids:
+- semantic-similarity-classification
+pretty_name: WikiSection (en_city, en_disease)
+tags:
+- text segmentation
+- document segmentation
+- topic segmentation
+- topic shift detection
+- semantic chunking
+- chunking
+- nlp
+- wikipedia
+dataset_info:
+- config_name: en_city
+  features:
+  - name: id
+    dtype: string
+  - name: title
+    dtype: string
+  - name: sent_ids
+    sequence: string
+  - name: sentences
+    sequence: string
+  - name: titles_mask
+    sequence: uint8
+  - name: labels
+    sequence:
+      class_label:
+        names:
+          '0': neg
+          '1': pos
+  splits:
+  - name: train
+    num_bytes: 105236889
+    num_examples: 13679
+  - name: validation
+    num_bytes: 15693016
+    num_examples: 1953
+  - name: test
+    num_bytes: 31140798
+    num_examples: 3907
+  download_size: 94042594
+  dataset_size: 152070703
+- config_name: en_disease
+  features:
+  - name: id
+    dtype: string
+  - name: title
+    dtype: string
+  - name: sent_ids
+    sequence: string
+  - name: sentences
+    sequence: string
+  - name: titles_mask
+    sequence: uint8
+  - name: labels
+    sequence:
+      class_label:
+        names:
+          '0': neg
+          '1': pos
+  splits:
+  - name: train
+    num_bytes: 22409988
+    num_examples: 2513
+  - name: validation
+    num_bytes: 3190201
+    num_examples: 359
+  - name: test
+    num_bytes: 6088470
+    num_examples: 718
+  download_size: 94042594
+  dataset_size: 31688659
 ---
+# Dataset Card for WikiSection (en_city, en_disease) Dataset

preprocess_util.py

@@ -0,0 +1,111 @@
+import json
+import os
+
+### NLTK ###
+try:
+    import nltk
+    try: 
+        nltk.data.find('tokenizers/punkt')
+    except LookupError:
+        nltk.download('punkt')
+    
+    def nltk_sent_tokenize(text: str):
+        return nltk.sent_tokenize(text)
+except ImportError:
+    pass
+
+### Spacy ###
+try:
+    import spacy
+    exclude = ["tok2vec", "tagger", "parser", "attribute_ruler", "lemmatizer", "ner"]
+    try:
+        spacy_nlp = spacy.load('en_core_web_sm', exclude=exclude)
+    except OSError:
+        spacy.cli.download('en_core_web_sm')
+        spacy_nlp = spacy.load('en_core_web_sm', exclude=exclude)
+    spacy_nlp.enable_pipe("senter")
+    # print(spacy_nlp.pipe_names)
+    
+    def spacy_sent_tokenize(text: str):
+        return [sent.text for sent in spacy_nlp(text).sents]
+except ImportError:
+    pass
+
+### Segtok ###
+try:
+    from segtok.segmenter import split_single  #, split_multi
+    
+    def segtok_sent_tokenize(text: str):
+        return split_single(text)
+except ImportError:
+    pass
+
+
+def sent_tokenize(text: str, method: str):
+    if method == 'nltk':
+        stok = nltk_sent_tokenize
+    elif method == 'spacy':
+        stok = spacy_sent_tokenize
+    elif method == 'segtok':
+        stok = segtok_sent_tokenize
+    else:
+        raise ValueError(f"Invalid sentence tokenizer method: {method}")
+    
+    return [ssent for sent in stok(text) if (ssent := sent.strip())]
+
+
+def parse_split(filepath: str, drop_titles: bool = False, sent_tokenize_method: str = 'nltk'):
+    
+    with open(filepath, 'r') as f:
+        data = json.load(f)
+    
+    # docs = []
+    for i, row in enumerate(data):
+        id = row['id']
+        title = row['title']
+        # abstract = row.get('abstract')
+        text = row['text']
+        # print(f'\n{i}: {title}')
+        # print(text[:1000])
+        sections = row['annotations']
+        
+        doc = {
+            'id': id,
+            'title': title,
+            'sent_ids': [],
+            'sentences': [],
+            'titles_mask': [],
+            'labels': [],
+        }
+        
+        for sec_idx, sec in enumerate(sections):
+            
+            sec_title = sec['sectionHeading'].strip()
+            # sec_label = sec['sectionLabel']
+
+            sec_text = text[sec['begin']:sec['begin']+sec['length']]
+            sentences = sent_tokenize(sec_text, method=sent_tokenize_method)
+            
+            # If section is empty, continue
+            if not sentences:
+                continue
+        
+            # Add the title as a single sentence
+            if not drop_titles and sec_title:
+            # if not drop_titles and non_empty(sec_title):
+                doc['sent_ids'].append(f'{sec_idx}')
+                doc['sentences'].append(sec_title)
+                doc['titles_mask'].append(1)
+                doc['labels'].append(0)
+
+            # Add the sentences
+            for sent_idx, sent in enumerate(sentences):
+                doc['sent_ids'].append(f'{sec_idx}_{sent_idx}')
+                doc['sentences'].append(sent)
+                doc['titles_mask'].append(0)
+                doc['labels'].append(1 if sent_idx == len(sentences) - 1 else 0)
+        
+        if drop_titles:
+            doc.pop('titles_mask')
+                
+        yield doc

wikisection.py

@@ -0,0 +1,177 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
+#
+# 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.
+# TODO: Address all TODOs and remove all explanatory comments
+"""
+WikiSection dataset loading script responsible for downloading and extracting raw data files, followed by parsing the articles into lists of setnences and their binary text segmentation labels.
+See https://github.com/sebastianarnold/WikiSection for more information.
+
+Usage:
+    >>> from datasets import load_dataset
+    >>> dataset = load_dataset('saeedabc/wikisection', 'en_city', trust_remote_code=True, num_proc=8)
+    >>> dataset = load_dataset('saeedabc/wikisection', 'en_disease', trust_remote_code=True, num_proc=8)
+"""
+
+
+import os
+import datasets
+from dataclasses import dataclass
+from typing import Optional
+
+from .preprocess_util import parse_split
+
+
+# TODO: Add BibTeX citation
+# Find for instance the citation on arxiv or on the dataset repo/website
+_CITATION = """\
+@article{arnold2019sector,
+  author = {Arnold, Sebastian and Schneider, Rudolf and Cudré-Mauroux, Philippe and Gers, Felix A. and Löser, Alexander},
+  title = {SECTOR: A Neural Model for Coherent Topic Segmentation and Classification},
+  journal = {Transactions of the Association for Computational Linguistics},
+  volume = {7},
+  pages = {169-184},
+  year = {2019},
+  doi = {10.1162/tacl\_a\_00261}
+}
+"""
+
+# TODO: Add description of the dataset here
+# You can copy an official description
+_DESCRIPTION = """\
+The WikiSection dataset consist of segmented Wikipedia articles. 
+Two notable subsets within this dataset are `en_city` and `en_disease`:
+- `en_city` contains 19.5k articles about diverse city-related topics. 
+- `en_disease` consists of 3.6k medical and health-related documents with scientific details. 
+This dataset is formulated as a sentence-level sequence labelling task for text segmentation.
+"""
+
+# TODO: Add a link to an official homepage for the dataset here
+_HOMEPAGE = "https://github.com/sebastianarnold/WikiSection"
+
+# TODO: Add the licence for the dataset here if you can find it
+_LICENSE = "MIT License"
+
+# TODO: Add link to the official dataset URLs here
+# The HuggingFace Datasets library doesn't host the datasets but only points to the original files.
+# This can be an arbitrary nested dict/list of URLs (see below in `_split_generators` method)
+_URL = "https://github.com/sebastianarnold/WikiSection/raw/master/wikisection_dataset_json.tar.gz"
+
+
+@dataclass
+class WikiSectionBuilderConfig(datasets.BuilderConfig):
+    """BuilderConfig for WikiSection dataset."""
+
+    drop_titles: Optional[bool] = False
+    sent_tokenize_method: Optional[str] = 'nltk'
+
+    def __post_init__(self):
+        if self.sent_tokenize_method not in ['nltk', 'spacy', 'segtok']:
+            raise ValueError(f"Invalid sentence tokenizer method: {self.sent_tokenize_method}")
+        super(WikiSectionBuilderConfig, self).__post_init__()
+
+
+# TODO: Name of the dataset usually matches the script name with CamelCase instead of snake_case
+class WikiSection(datasets.GeneratorBasedBuilder):
+    """WikiSection dataset formulated as a sentence-level sequence labelling task for text segmentation."""
+
+    VERSION = datasets.Version("1.0.0")
+
+    # This is an example of a dataset with multiple configurations.
+    # If you don't want/need to define several sub-sets in your dataset,
+    # just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.
+
+    # If you need to make complex sub-parts in the datasets with configurable options
+    # You can create your own builder configuration class to store attribute, inheriting from datasets.BuilderConfig
+    BUILDER_CONFIG_CLASS = WikiSectionBuilderConfig
+
+    # You will be able to load one or the other configurations in the following list with
+    # data = datasets.load_dataset('name', 'config1')
+    BUILDER_CONFIGS = [
+        WikiSectionBuilderConfig(name="en_city", version=VERSION, description="en_city subset of the WikiSection dataset."),
+        WikiSectionBuilderConfig(name="en_disease", version=VERSION, description="en_disease subset of the WikiSection dataset."),
+    ]
+    # DEFAULT_CONFIG_NAME = "default"  # It's not mandatory to have a default configuration. Just use one if it make sense.
+
+    def _info(self):
+        # TODO: This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
+        # if self.config.name == "config1": ... # This is the name of the configuration selected in BUILDER_CONFIGS above
+
+        features = datasets.Features(
+            {
+                "id": datasets.Value("string"),         # document id --> [doc0, doc1, ...]
+                "title": datasets.Value("string"),
+                "sent_ids": datasets.Sequence(          # document sentence ids --> [[doc0_sent0, doc0_sent1, ...], ...]
+                    datasets.Value("string")
+                ),
+                "sentences": datasets.Sequence(
+                    datasets.Value("string")
+                ),
+                "titles_mask": datasets.Sequence(
+                    datasets.Value("uint8")
+                ),
+                "labels": datasets.Sequence(
+                    datasets.ClassLabel(num_classes=2, names=['neg', 'pos'])
+                ),
+            }
+        )
+        
+        if self.config.drop_titles:
+            features.pop("titles_mask")
+
+        return datasets.DatasetInfo(
+            # This is the description that will appear on the datasets page.
+            description=_DESCRIPTION,
+            # This defines the different columns of the dataset and their types
+            features=features,  # Here we define them above because they are different between the two configurations
+            # If there's a common (input, target) tuple from the features, uncomment supervised_keys line below and
+            # specify them. They'll be used if as_supervised=True in builder.as_dataset.
+            # supervised_keys=("sentence", "label"),
+            # Homepage of the dataset for documentation
+            homepage=_HOMEPAGE,
+            # License for the dataset if available
+            license=_LICENSE,
+            # Citation for the dataset
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        # TODO: This method is tasked with downloading/extracting the data and defining the splits depending on the configuration
+        # If several configurations are possible (listed in BUILDER_CONFIGS), the configuration selected by the user is in self.config.name
+
+        # dl_manager is a datasets.download.DownloadManager that can be used to download and extract URLS
+        # It can accept any type or nested list/dict and will give back the same structure with the url replaced with path to local files.
+        # By default the archives will be extracted and a path to a cached folder where they are extracted is returned instead of the archive
+
+        splits = {'train': datasets.Split.TRAIN, 'validation': datasets.Split.VALIDATION, 'test': datasets.Split.TEST}
+        
+        data_dir = dl_manager.download_and_extract(_URL)
+        
+        out = []
+        for split in splits:
+            split_path = os.path.join(data_dir, f"wikisection_{self.config.name}_{split}.json")
+            # split_shard_paths = [ssp for f in os.listdir(split_path) if os.path.isdir(ssp := os.path.join(split_path, f))]
+            out.append(
+                datasets.SplitGenerator(
+                    name=splits[split],
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={"filepath": split_path, "split": split}
+                )
+            )
+        return out
+    
+    # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
+    def _generate_examples(self, filepath: str, split: str):            
+        for doc in parse_split(filepath, 
+                               drop_titles=self.config.drop_titles, 
+                               sent_tokenize_method=self.config.sent_tokenize_method):
+            yield doc['id'], doc