adding Danish subset of the NCC

CHANGELOG.md

@@ -5,6 +5,15 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/).
 
+
+## [v1.0.12] - 2025-04-16
+
+### Added
+
+- Added new dataset ( ~1.61B tokens)
+  - Norwegian Colossal Corpus (ncc)
+  
+
 ## [v1.0.11] - 2025-03-29
 
 ### Added

README.md

@@ -125,6 +125,10 @@ configs:
   data_files:
   - split: train
     path: data/nota/*.parquet
+- config_name: ncc
+  data_files:
+  - split: train
+    path: data/ncc/*.parquet
 annotations_creators:
 - no-annotation
 language_creators:
@@ -158,7 +162,7 @@ https://github.com/huggingface/datasets/blob/main/templates/README_guide.md
 <!-- START README TABLE -->
 |              |                                                                                                                                                             |
 | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Version** | 1.0.11 ([Changelog](/CHANGELOG.md)) |
+| **Version** | 1.0.13 ([Changelog](/CHANGELOG.md)) |
 | **Language** | dan, dansk, Danish                                                                                                                                          |
 | **License**  | Permissible, See the respective dataset                                                                                                                     |
 | **Models**   | For model trained used this data see [danish-foundation-models](https://huggingface.co/danish-foundation-models)                                            |

data/ncc/create.py

@@ -0,0 +1,256 @@
+# /// script
+# requires-python = ">=3.12"
+# dependencies = [
+#     "datasets>=3.2.0",
+# ]
+# ///
+# setup
+from pathlib import Path
+from datetime import datetime
+from datasets import Dataset, load_dataset
+
+source = "ncc"
+
+
+# functions
+def word_tokenize(text: str) -> list[str]:
+    """
+    Tokenizes a string into words, splitting on whitespace and punctuation.
+
+    Example:
+        >>> word_tokenize("Hello, world!")
+        ['Hello', ',', 'world', '!']
+        >>> word_tokenize("This is a test.")
+        ['This', 'is', 'a', 'test', '.']
+        >>> word_tokenize("Many spaces    between words.")
+        ['Many', 'spaces', 'between', 'words', '.']
+    """
+
+    punkt = [",", ".", "!", "?", ":", ";", "(", ")", "[", "]", "{", "}", '"', "'"]
+    for p in punkt:
+        text = text.replace(p, f" {p} ")
+    return text.split()
+
+
+def count_min_target(given_list: list, target_list: list, min: int) -> bool:
+    """
+    Iterates through given list, until at least min items match any items from target list
+
+    """
+    c_item = 0
+    given_list_iter = iter(given_list)
+    while c_item < min:
+        try:
+            current_item = next(given_list_iter)
+            if current_item in target_list:
+                c_item += 1
+        except StopIteration:
+            break
+
+    return c_item == min
+
+
+def min_alpha_ratio(text: str | list[str], min: float = 0.7) -> bool:
+    """
+    If not split already to words, splits text with word_tokenize()
+    Calculates ratio of words with only alphabetical characters
+    Compares it to min
+
+    """
+    if type(text) is str:
+        text = word_tokenize(text)
+    else:
+        pass
+
+    alpha_ratio = 1 - sum(not word.isalpha() for word in text) / len(text)
+
+    return alpha_ratio >= min
+
+
+def lookup_ref_dict(ref_dictionary: dict[str, list[str]], string_item: str) -> str:
+    """
+    Takes a reference dictionary and an item,
+    Outputs the key, where the item contains any element in the value list.
+    e.g:
+    ref_dictionary = {"ab": ["a","b"],
+                      "cd": ["c","d"]
+    }
+    string_item = "*a*" | "*b*"
+    output = "ab"
+
+    !!! WARNING: will return last match !!!
+    string_item = "*a*d*"
+    output = "cd"
+
+    """
+    for key, values in ref_dictionary.items():
+        for each_value in values:
+            if each_value in string_item:
+                output = key
+            else:
+                pass
+
+    try:
+        return output
+    except UnboundLocalError:
+        print(f"WARNING: ref_lookup_dict() unknown value in data --> {string_item}")
+
+
+class document_filter:
+    """
+    Document filtering from a dictionary
+    Made for https://huggingface.co/datasets/NbAiLab/NCC
+
+    confidence in language > 0.5, -> below mostly noise
+    check language == da, -> unwanted data if not
+    text length > 10 words, -> short text, likely noise
+    check alpha > 0.7, -> too many words with numbers in them, likely
+    noise
+    stopwords > 2, -> no stopwords, likely not coherent text, likely
+    noise
+
+    """
+
+    def __init__(
+        self,
+        req_language: str = "da",
+        min_conf: float = 0.5,
+        min_w_l: int = 10,
+        min_alpha: float = 0.7,
+        min_s_w_l: int = 2,
+    ):
+        self.req_language = req_language
+        self.min_conf = min_conf
+        self.min_w_l = min_w_l
+        self.min_alpha = min_alpha
+        self.min_s_w_l = min_s_w_l
+        self.date_today = datetime.now().strftime("%Y-%m-%d")
+
+    def first_layer_filter(self, meta_document: dict[str, str | int]) -> bool:
+        """
+        Filtering based on already available data in the dictionary:
+        Language
+        Confidence in language classification
+
+        """
+        language = meta_document.get("lang_fasttext")
+        confidence = float(meta_document.get("lang_fasttext_conf"))
+
+        return (confidence >= self.min_conf) and (language == self.req_language)
+
+    def second_layer_filter(self, text: str, stop_words: list[str]) -> bool:
+        """
+        Filtering based on data derived from the document text:
+        text length:
+            text is segmented to words by word_tokenize()
+            measured by len()
+        alpha ratio:
+            by min_alpha_ratio()
+        minimum stop words present:
+            by count_min_target()
+        """
+
+        word_list = word_tokenize(text)
+
+        text_length_pass = len(word_list) >= self.min_w_l
+        alpha_pass = min_alpha_ratio(word_list, self.min_alpha)
+        s_w_pass = count_min_target(word_list, stop_words, self.min_s_w_l)
+
+        return text_length_pass and alpha_pass and s_w_pass
+
+    def dynaword_format(
+        self,
+        meta_document: dict[str, str | int],
+        ref_dictionary_license: dict[str, list[str]],
+        ref_dictionary_domain: dict[str, list[str]],
+    ) -> dict[str, str | dict[str, str]]:
+        """Reformats data to fit dynaword standards"""
+
+        text = meta_document.get("text")
+        id = meta_document.get("id")
+        date = meta_document.get("publish_year")
+        doc_type = meta_document.get("doc_type")
+
+        newdata = {
+            "text": text,
+            "source": "ncc",
+            "id": id,
+            "added": self.date_today,
+            "created": f"{date}-01-01, {date}-12-31",
+            "license": lookup_ref_dict(ref_dictionary_license, doc_type),
+            "domain": lookup_ref_dict(ref_dictionary_domain, doc_type),
+            "metadata": {
+                "source-pretty": "Norwegian Colossal Corpus",
+                "source-type": doc_type,
+            },
+        }
+
+        return newdata
+
+
+# main
+def main():
+    # filtering setup
+    stop_words = [
+       'ad', 'af', 'alle', 'alt', 'anden', 'at', 'blev', 'blive', 'bliver', 'da', 'de', 'dem', 'den', 'denne', 'der', 'deres', 'det', 'dette', 'dig', 'din', 'disse', 'dog', 'du', 'efter', 'eller', 'en', 'end', 'er', 'et', 'for', 'fra', 'ham', 'han', 'hans', 'har', 'havde', 'have', 'hende', 'hendes', 'her', 'hos', 'hun', 'hvad', 'hvis', 'hvor', 'i', 'ikke', 'ind', 'jeg', 'jer', 'jo', 'kunne', 'man', 'mange', 'med', 'meget', 'men', 'mig', 'min', 'mine', 'mit', 'mod', 'ned', 'noget', 'nogle', 'nu', 'når', 'og', 'også', 'om', 'op', 'os', 'over', 'på', 'selv', 'sig', 'sin', 'sine', 'sit', 'skal', 'skulle', 'som', 'sådan', 'thi', 'til', 'ud', 'under', 'var', 'vi', 'vil', 'ville', 'vor', 'være', 'været'
+    ]
+    doc_filter = document_filter()
+    da_data = []
+
+    # formatting setup
+    ref_dictionary_license = {
+        "other": ["government", "parliament", "publicreport", "lovdata", "maalfrid","wikipedia"],
+        "cc0-1.0": ["newspaper", "book"]
+    }
+
+    ref_dictionary_domain = {
+        "Legal": ["government", "parliament", "publicreport", "lovdata", "maalfrid"],
+        "News": ["newspaper"],
+        "Wiki & Books": ["book", "wikipedia"],
+    }
+
+
+    ## load all data first to get splits, then load and filter by split
+    data = load_dataset("NbAiLab/NCC", streaming=True)
+    data_splits=list(reversed(data.keys()))
+
+
+    for current_split in data_splits:
+        data = load_dataset("NbAiLab/NCC", streaming=True, split=current_split)
+        data_iter = iter(data)
+
+        # filtering and formatting
+        while True:
+            try:
+                current_text = next(data_iter)
+
+                meta_data_filtering = doc_filter.first_layer_filter(current_text)
+
+                if meta_data_filtering:
+                    text_filtering = doc_filter.second_layer_filter(
+                        current_text.get("text"), stop_words
+                    )
+
+                    if meta_data_filtering and text_filtering:
+                        # formatting
+                        dynaform = doc_filter.dynaword_format(
+                            current_text, ref_dictionary_license, ref_dictionary_domain
+                        )
+
+                        da_data.append(dynaform)
+                    else:
+                        pass
+                else:
+                    pass
+                
+            except StopIteration:
+                break
+
+    ### saving
+    ds = Dataset.from_list(da_data)
+    save_path = Path(__file__).parent / f"{source}.parquet"
+    ds.to_parquet(save_path)
+
+
+if __name__ == "__main__":
+    main()

data/ncc/descriptive_stats.json

@@ -0,0 +1,7 @@
+{
+  "number_of_samples": 65301,
+  "average_document_length": 70916.04932543146,
+  "number_of_tokens": 1606197164,
+  "language": "dan, dansk, Danish",
+  "revision": "72ebab94b5331169630c823308470471687bb921"
+}

data/ncc/ncc.md

@@ -0,0 +1,132 @@
+---
+pretty_name: Norwegian Colossal Corpus
+language:
+  - da
+license: other
+license_name: CC0 1.0, NLOD 2.0, CC BY-SA 3.0
+task_categories:
+  - text-generation
+  - fill-mask
+task_ids:
+  - language-modeling
+---
+
+# Dataset Card for Norwegian Colossal Corpus
+
+<!-- START-SHORT DESCRIPTION -->
+Danish language subset of [NCC](https://huggingface.co/datasets/NbAiLab/NCC)
+<!-- END-SHORT DESCRIPTION -->
+
+The Norwegian Colossal Corpus is a collection of multiple smaller Norwegian corpuses suitable for training large language models.   \
+(desc. taken from [NCC](https://huggingface.co/datasets/NbAiLab/NCC))
+
+This subset is the result of the following filtering from all availabel data splits:
+- Document is marked as Danish
+- Confidence of the language classificationis at least 0.5
+- Document has at least 10 words (whitespace separated strings + punctuation)
+- The ratio of all words / words with only alphabetical characters is at least 0.7
+- The document contains at least 2 Danish stop words
+
+
+
+## Dataset Description
+
+<!-- START-DESC-STATS -->
+- **Language**: dan, dansk, Danish
+- **Number of samples**: 65.30K
+- **Number of tokens (Llama 3)**: 1.61B
+- **Average document length (characters)**: 70916.05
+<!-- END-DESC-STATS -->
+
+
+## Dataset Structure
+An example from the dataset looks as follows.
+
+
+<!-- START-SAMPLE -->
+```py
+{
+  "text": "h) ved beregningen omhandlet i litra f) kan pengemarkedsinstrumenter eller andele eller kapitalandel[...]",
+  "source": "ncc",
+  "id": "maalfrid_2ede28a2c9ba7b4c0162681385ab60f99e021bfa_25",
+  "added": "2025-04-15",
+  "created": "2021-01-01, 2021-12-31",
+  "license": "other",
+  "domain": "Legal",
+  "metadata": {
+    "source-pretty": "Norwegian Colossal Corpus",
+    "source-type": "maalfrid_regjeringen"
+  }
+}
+```
+
+### Data Fields
+
+An entry in the dataset consists of the following fields:
+
+- `text`(`str`): The content of the document.
+- `source` (`str`): The source of the document (see [Source Data](#source-data)).
+- `id` (`str`): An unique identifier for each document.
+- `added` (`str`): An date for when the document was added to this collection.
+- `created` (`str`): An date range for when the document was originally created.
+- `license` (`str`): The license of the document. The licenses vary according to the source. 
+- `domain` (`str`): The domain of the source
+- `metadata/source-pretty` (`str`): The long form version of the short-form source name
+- `metadata/*`: Potentially additional metadata
+<!-- END-SAMPLE -->
+
+
+### Dataset Statistics
+
+<!-- START-DATASET PLOTS -->
+<img src="./images/dist_document_length.png" width="600" style="margin-right: 10px;" />
+<img>
+<!-- END-DATASET PLOTS -->
+
+
+
+## Additional Information
+
+## License Information
+The dataset consists of multiple types of documents, with various licenses:
+- [NLOD 2.0](https://data.norge.no/nlod/en/2.0) Norwegian government, parliament and legal documents domain == "Legal" and license == "other" in the dataset
+- [CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/)
+- [CC BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/) Wikipedia articles marked as domain == "Wiki & Books" and license == "other"
+
+
+### Citation Information
+```bash
+@inproceedings{kummervold-etal-2022-norwegian-colossal,
+  title     = {The {N}orwegian colossal corpus: A text corpus for training large {N}orwegian language models},
+  author    = {Kummervold, Per E  and
+               Wetjen, Freddy    and
+               De la Rosa, Javier},
+  booktitle = {Proceedings of the Thirteenth Language Resources and Evaluation Conference (LREC)},
+  year      = {2022},
+  address   = {Marseille, France},
+  publisher = {European Language Resources Association},
+  url       = {https://aclanthology.org/2022.lrec-1.410},
+  pages     = {3852--3860},
+  abstract  = {Norwegian has been one of many languages lacking sufficient available text to train quality language models. In an attempt to bridge this gap, we introduce the Norwegian Colossal Corpus (NCC), which comprises 49GB of clean Norwegian textual data containing over 7B words. The NCC is composed of different and varied sources, ranging from books and newspapers to government documents and public reports, showcasing the various uses of the Norwegian language in society. The corpus contains mainly Norwegian Bokmål and Norwegian Nynorsk. Each document in the corpus is tagged with metadata that enables the creation of sub-corpora for specific needs. Its structure makes it easy to combine with large web archives that for licensing reasons could not be distributed together with the NCC. By releasing this corpus openly to the public, we hope to foster the creation of both better Norwegian language models and multilingual language models with support for Norwegian.},
+}
+
+@inproceedings{kummervold-etal-2021-operationalizing,
+  title     = {Operationalizing a National Digital Library: The Case for a {N}orwegian Transformer Model},
+  author    = {Kummervold, Per E  and
+               De la Rosa, Javier  and
+               Wetjen, Freddy  and
+               Brygfjeld, Svein Arne},
+  booktitle = {Proceedings of the 23rd Nordic Conference on Computational Linguistics (NoDaLiDa)},
+  year      = {2021},
+  address   = {Reykjavik, Iceland (Online)},
+  publisher = {Linköping University Electronic Press, Sweden},
+  url       = {https://aclanthology.org/2021.nodalida-main.3},
+  pages     = {20--29},
+  abstract  = {In this work, we show the process of building a large-scale training set from digital and digitized collections at a national library.
+  The resulting Bidirectional Encoder Representations from Transformers (BERT)-based language model for Norwegian outperforms multilingual BERT (mBERT) models
+  in several token and sequence classification tasks for both Norwegian Bokmål and Norwegian Nynorsk. Our model also improves the mBERT performance for other
+  languages present in the corpus such as English, Swedish, and Danish. For languages not included in the corpus, the weights degrade moderately while keeping strong multilingual properties. Therefore,
+  we show that building high-quality models within a memory institution using somewhat noisy optical character recognition (OCR) content is feasible, and we hope to pave the way for other memory institutions to follow.},
+}
+
+```

data/ncc/ncc.parquet

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

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "danish-dynaword"
-version = "1.0.11"
+version = "1.0.12"
 description = "project code for the danish dynaword project"
 readme = "README.md"
 requires-python = ">=3.12,<3.13" # 3.13 have issues with spacy and pytorch

uv.lock

@@ -202,7 +202,7 @@ wheels = [
 
 [[package]]
 name = "danish-dynaword"
-version = "1.0.11"
+version = "1.0.12"
 source = { virtual = "." }
 dependencies = [
     { name = "datasets" },