ncc_newspaper separated from ncc

CHANGELOG.md

@@ -6,12 +6,12 @@ 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
+## [v1.0.12] - 2025-05-05
 
 ### Added
 
-- Added new dataset ( ~1.61B tokens)
-  - Norwegian Colossal Corpus (ncc)
+- Added new datasets
+  - Norwegian Colossal Corpus (newspaper) (~1M tokens)
   
 
 ## [v1.0.11] - 2025-03-29

README.md

@@ -125,10 +125,10 @@ configs:
   data_files:
   - split: train
     path: data/nota/*.parquet
-- config_name: ncc
+- config_name: ncc_newspaper
   data_files:
   - split: train
-    path: data/ncc/*.parquet
+    path: data/ncc_newspaper/*.parquet
 annotations_creators:
 - no-annotation
 language_creators:
@@ -334,8 +334,8 @@ Below follows a brief overview of the sources in the corpus along with their ind
 | [hest]              | Samples from the Danish debate forum www.heste-nettet.dk                                                                                      | 389.33M     | [CC-0]                 |
 | [retsinformationdk] | [retsinformation.dk](https://www.retsinformation.dk) (legal-information.dk) the official legal information system of Denmark                  | 516.54M     | [Danish Copyright Law] |
 | [cellar]            | The official digital repository for European Union legal documents and open data                                                              | 1.28B       | [CC-BY-SA 4.0]         |
-| [ncc]             | Danish subset of [NCC](https://huggingface.co/datasets/NbAiLab/NCC), The Norwegian Colossal Corpus                       | 1.61B      | [CC-0] [NLOD 2.0] [CC-BY-SA 3.0]                |
-| **Total**           |                                                                                                                                               | 5.1B       |                        |
+| [ncc_newspaper]             | Danish subset of [NCC](https://huggingface.co/datasets/NbAiLab/NCC), The Norwegian Colossal Corpus (newspaper)                       | ?      | [CC-0]                |
+| **Total**           |                                                                                                                                               | 3.49B       |                        |
 
 [ai-aktindsigt]: data/ai-aktindsigt/ai-aktindsigt.md
 [cellar]: data/cellar/cellar.md
@@ -367,7 +367,7 @@ Below follows a brief overview of the sources in the corpus along with their ind
 [nordjyllandnews]: data/nordjyllandnews/nordjyllandnews.md
 [relig]: data/relig/relig.md
 [nota]: data/nota/nota.md
-[ncc]: data/ncc/ncc.md
+[ncc_newspaper]: data/ncc_newspaper/ncc_newspaper.md
 
 
 [CC-0]: https://creativecommons.org/publicdomain/zero/1.0/legalcode.en

data/ncc/create.py

@@ -1,256 +0,0 @@
-# /// 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

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

data/ncc_newspaper/create.py

@@ -0,0 +1,333 @@
+# /// script
+# requires-python = ">=3.12"
+# dependencies = [
+#     "datasets>=3.2.0"
+# ]
+# ///
+# setup
+import logging
+import re
+import inspect
+
+from pathlib import Path
+from datetime import datetime
+from collections import defaultdict
+from collections.abc import Callable
+
+import pandas as pd
+from datasets import Dataset, load_dataset
+
+logger = logging.getLogger(__name__)
+########## edit manually for each source
+hf_path = "NbAiLab/NCC"
+source = "ncc_newspaper"
+license = "cc0-1.0"
+domain = "News"
+num_proc = 8
+##########
+today = datetime.now().strftime("%Y-%m-%d")
+
+#stop words taken from spaCy
+#https://github.com/explosion/spaCy/blob/master/spacy/lang/da/stop_words.py
+# Source: Handpicked by Jens Dahl Møllerhøj.
+spacy_sw = set(
+    """
+af aldrig alene alle allerede alligevel alt altid anden andet andre at
+
+bag begge blandt blev blive bliver burde bør
+
+da de dem den denne dens der derefter deres derfor derfra deri dermed derpå derved det dette dig din dine disse dog du
+
+efter egen eller ellers en end endnu ene eneste enhver ens enten er et
+
+flere flest fleste for foran fordi forrige fra få før først
+
+gennem gjorde gjort god gør gøre gørende
+
+ham han hans har havde have hel heller hen hende hendes henover her herefter heri hermed herpå hun hvad hvem hver hvilke hvilken hvilkes hvis hvor hvordan hvorefter hvorfor hvorfra hvorhen hvori hvorimod hvornår hvorved
+
+i igen igennem ikke imellem imens imod ind indtil ingen intet
+
+jeg jer jeres jo
+
+kan kom kommer kun kunne
+
+lad langs lav lave lavet lidt lige ligesom lille længere
+
+man mange med meget mellem men mens mere mest mig min mindre mindst mine mit må måske
+
+ned nemlig nogen nogensinde noget nogle nok nu ny nyt nær næste næsten
+
+og også om omkring op os over overalt
+
+på
+
+samme sammen selv selvom senere ses siden sig sige skal skulle som stadig synes syntes så sådan således
+
+temmelig tidligere til tilbage tit
+
+ud uden udover under undtagen
+
+var ved vi via vil ville vore vores vær være været
+
+øvrigt
+""".split()
+)
+
+# 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 alpha_ratio(text: str | list[str]) -> float:
+    """
+    If not split already to words, splits text with word_tokenize()
+    Calculates ratio of words with only alphabetical characters
+
+    """
+    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
+
+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 dynaword_format(
+    meta_document: dict[str, str | int]
+    ) -> 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": source,
+         "id": id,
+         "added": today,
+         "created": f"{date}-01-01, {date}-12-31",
+         "license": license,
+         "domain": domain,
+         "metadata": {
+                "source-pretty": f"Norwegian Colossal Corpus ({re.sub("ncc_","",source)})",
+                "source-type": doc_type,
+            },
+        }
+
+    return newdata
+
+def log_pre_filter_lang_data(lang_metadata : dict[str,dict[str,int]],
+                              filtered_ds: Dataset):
+    """
+    Function for logging changes in a large dataset,
+    based on the metadata pre filering and the filtered dataset,
+    used for language filtering
+    """
+    all_docs = sum(lang_metadata[source].values())
+    no_docs = lang_metadata[source].get("no")
+    da_docs = lang_metadata[source].get("da")
+    no_perc = round(no_docs/all_docs*100,4)
+    da_perc = round(da_docs/all_docs*100,4)
+
+    f_length = len(filtered_ds)
+    f_perc = round(f_length/da_docs*100,4)
+    f_total_perc = round(f_length/all_docs*100,4)
+
+    logger.info(f"Documents of {source}:")
+    logger.info(f"NO: {no_docs}, {no_perc}% ; DA: {da_docs}, {da_perc}%")
+    logger.info(f"After language confidence filtering:")
+    logger.info(f"DA: {f_length}, lost: {100-f_perc}%")
+    logger.info(f"Total document change:")
+    logger.info(f"{all_docs} -> {f_length}, loss: {100-f_total_perc}%")
+
+def get_var_name(var):
+    """ outputs the variable name """
+    callers_local_vars = inspect.currentframe().f_back.f_back.f_back.f_locals.items()
+    return [var_name for var_name, var_val in callers_local_vars if var_val is var]
+
+def filter_with_changelog(filter_func:Callable[[Dataset],Dataset],
+                          dataset:Dataset) -> Dataset:
+    """
+    Function, which takes a filter and a dataset.
+    Counts text docs and tokens before and after filtering,
+    Saves filtering changes to log.
+    """
+
+    filter_name = get_var_name(filter_func)
+    pre_filter_docs = len(dataset)
+    pre_filter_tokens= sum(len(word_tokenize(i["text"])) for i in dataset)
+
+    dataset = dataset.filter(filter_func,num_proc=num_proc)
+
+    post_filter_docs = len(dataset)
+    post_filter_tokens= sum(len(word_tokenize(i["text"])) for i in dataset)
+    tokens_removed = round((1-(post_filter_tokens/pre_filter_tokens))*100,2)
+    docs_removed = round((1-(post_filter_docs/pre_filter_docs))*100,2)
+    
+    logger.info(f"FILTER: {filter_name}")
+    logger.info(f"TOKENS: pre: {pre_filter_tokens}, post: {post_filter_tokens}, loss: {tokens_removed}%")
+    logger.info(f"DOCUMENTS: pre: {pre_filter_docs}, post: {post_filter_docs}, loss: {docs_removed}%")
+    
+    return dataset
+
+
+# filters
+source_filter = lambda ds : re.sub("ncc_","",source) in ds["doc_type"]
+length_filter = lambda ds: len(word_tokenize(ds["text"])) >= 10
+too_long_filter = lambda ds: len(word_tokenize(ds["text"])) > 1e5
+alpha_filter = lambda ds: alpha_ratio(ds["text"]) >= 0.7
+stop_word_filter = lambda ds: count_min_target(word_tokenize(ds["text"]),spacy_sw,2)
+
+samples_pr_source: dict = defaultdict(lambda: defaultdict(int))
+def language_filter_with_desc_stats(ds:Dataset) -> bool:
+  """ 
+  Language filtering in a streamed dataset while logging all languages 
+  """
+  s = source
+  language = ds["lang_fasttext"]
+  samples_pr_source[s][language] += 1
+
+  language_filter = ds["lang_fasttext"] == "da" and float(ds["lang_fasttext_conf"]) >= 0.5
+
+  return language_filter
+
+#quality checks
+def quality_checks(ds:Dataset) -> Dataset:
+    """ 
+    Quality checks for:
+    - no duplicate ids
+    - no duplicate texts
+    - logs texts > 1e5 tokens
+    """
+    #convert to pandas for the drop_duplicates() 
+    df = pd.DataFrame(ds)
+    # remove duplicate ids
+    len_df = len(df)
+    df = df.drop_duplicates(subset=["id"])
+    logger.info(f"Removed {len_df - len(df)} duplicate ids")
+    # remove rows with duplicate text
+    len_df = len(df)
+    df = df.drop_duplicates(subset=["text"])
+    logger.info(f"Removed {len_df - len(df)} rows with duplicate text")
+    #reconvert and remove index
+    ds_f = Dataset.from_pandas(df,preserve_index=False)
+    try:
+        ds_f["__index_level_0__"]
+        ds_f = ds_f.remove_columns("__index_level_0__")
+    except KeyError:
+        pass
+
+    assert len(set(ds_f["id"])) == len(ds_f), "IDs are not unique"
+    assert len(set(ds_f["text"])) == len(ds_f), "Texts are not unique"
+
+    long_texts = ds_f.filter(too_long_filter,num_proc=num_proc)
+    if len(long_texts["id"]) > 0:
+        logger.info(f"{len(long_texts["id"])} Long texts (>~1e5 tokens) found")
+        for id in long_texts["id"]:
+            logger.info(f"id: {id}")
+    else:
+        logger.info("No long texts (>~1e5 tokens) found")
+
+    return ds_f
+
+#main
+def main():
+    #load all splits
+    logger.info(f"Loading data from: {hf_path}")
+    data = load_dataset(hf_path, streaming=True)
+    data_list = []
+
+    for split in data:
+        #filter by metadata
+        logger.info(f"Processing source: {source}, split: {split}")
+        s_data=data[split].filter(source_filter)
+
+
+        logger.info(f"Processing language, split: {split}")
+        s_data=s_data.filter(language_filter_with_desc_stats)
+
+        #convert from iterable dataset
+        data_iter = iter(s_data)
+        while True:
+            try:
+                data_list.append(next(data_iter))
+            except StopIteration:
+                break
+    danish_data = Dataset.from_list(data_list)
+    del data_list
+    
+    #log language changes
+    log_pre_filter_lang_data(samples_pr_source,danish_data)
+    
+    #convert to dynaword format
+    logger.info("Assembling whole dataset for filtering")
+    danish_data = danish_data.map(dynaword_format)
+    danish_data = danish_data.select_columns(["text",
+                                            "source",
+                                            "id",
+                                            "added",
+                                            "created",
+                                            "license",
+                                            "domain",
+                                            "metadata"])
+
+    #filter and log changes
+    danish_data = filter_with_changelog(length_filter,danish_data)
+    danish_data = filter_with_changelog(alpha_filter,danish_data)
+    danish_data = filter_with_changelog(stop_word_filter,danish_data)
+
+    #Quality checks
+    danish_data = quality_checks(danish_data)
+    
+    ### saving
+    save_path = Path(__file__).parent / f"{source}.parquet"
+    danish_data.to_parquet(save_path)
+
+
+
+if __name__ == "__main__":
+    log_path = Path(__file__).parent / f"{source}.log"
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+        handlers=[
+            logging.StreamHandler(),
+            logging.FileHandler(log_path),
+        ],
+    )
+    main()

data/ncc_newspaper/descriptive_stats.json

@@ -0,0 +1,7 @@
+{
+  "number_of_samples": 5373,
+  "average_document_length": 571.6929089893914,
+  "number_of_tokens": 1052890,
+  "language": "dan, dansk, Danish",
+  "revision": "ba61a9679152b7e3b74cf8f5b5fb36515c90e8d0"
+}

data/ncc_newspaper/ncc_newspaper.log

@@ -0,0 +1,39 @@
+2025-05-01 07:46:31,692 - INFO - Loading data from: NbAiLab/NCC
+2025-05-01 07:46:35,756 - INFO - Processing source: ncc_newspaper, split: train
+2025-05-01 07:46:35,757 - INFO - Processing language, split: train
+2025-05-01 09:08:21,490 - INFO - Loading data from: NbAiLab/NCC
+2025-05-01 09:08:35,451 - INFO - Processing source: ncc_newspaper, split: train
+2025-05-01 09:08:35,453 - INFO - Processing language, split: train
+2025-05-01 09:51:35,309 - WARNING - '(MaxRetryError('HTTPSConnectionPool(host=\'huggingface.co\', port=443): Max retries exceeded with url: /datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl (Caused by NameResolutionError("<urllib3.connection.HTTPSConnection object at 0x00000216E0676B40>: Failed to resolve \'huggingface.co\' ([Errno 11001] getaddrinfo failed)"))'), '(Request ID: 8c7cfa56-5cbe-4113-ae0b-9b9192c59c61)')' thrown while requesting GET https://huggingface.co/datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl
+2025-05-01 09:51:35,330 - WARNING - Retrying in 1s [Retry 1/5].
+2025-05-01 09:51:36,342 - WARNING - '(MaxRetryError('HTTPSConnectionPool(host=\'huggingface.co\', port=443): Max retries exceeded with url: /datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl (Caused by NameResolutionError("<urllib3.connection.HTTPSConnection object at 0x00000216EF3EC3E0>: Failed to resolve \'huggingface.co\' ([Errno 11001] getaddrinfo failed)"))'), '(Request ID: 8a52f0ab-4507-4af3-9de8-44600dcbe92b)')' thrown while requesting GET https://huggingface.co/datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl
+2025-05-01 09:51:36,343 - WARNING - Retrying in 2s [Retry 2/5].
+2025-05-01 09:51:38,346 - WARNING - '(MaxRetryError('HTTPSConnectionPool(host=\'huggingface.co\', port=443): Max retries exceeded with url: /datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl (Caused by NameResolutionError("<urllib3.connection.HTTPSConnection object at 0x00000216E0D0B920>: Failed to resolve \'huggingface.co\' ([Errno 11001] getaddrinfo failed)"))'), '(Request ID: 7004c6e6-9238-4ae1-9b2c-625361ec2495)')' thrown while requesting GET https://huggingface.co/datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl
+2025-05-01 09:51:38,347 - WARNING - Retrying in 4s [Retry 3/5].
+2025-05-01 10:34:26,967 - WARNING - '(MaxRetryError('HTTPSConnectionPool(host=\'huggingface.co\', port=443): Max retries exceeded with url: /datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl (Caused by NameResolutionError("<urllib3.connection.HTTPSConnection object at 0x00000216E0D08CE0>: Failed to resolve \'huggingface.co\' ([Errno 11001] getaddrinfo failed)"))'), '(Request ID: e818f8c8-4815-4b64-95f1-1ea5d68005b7)')' thrown while requesting GET https://huggingface.co/datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl
+2025-05-01 10:34:26,976 - WARNING - Retrying in 8s [Retry 4/5].
+2025-05-01 10:34:34,996 - WARNING - '(MaxRetryError('HTTPSConnectionPool(host=\'huggingface.co\', port=443): Max retries exceeded with url: /datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl (Caused by NameResolutionError("<urllib3.connection.HTTPSConnection object at 0x00000216E0D089E0>: Failed to resolve \'huggingface.co\' ([Errno 11001] getaddrinfo failed)"))'), '(Request ID: 3b7514c2-ff9c-4634-b738-535764ff6b86)')' thrown while requesting GET https://huggingface.co/datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl
+2025-05-01 10:34:34,996 - WARNING - Retrying in 8s [Retry 5/5].
+2025-05-01 10:34:43,000 - WARNING - '(MaxRetryError('HTTPSConnectionPool(host=\'huggingface.co\', port=443): Max retries exceeded with url: /datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl (Caused by NameResolutionError("<urllib3.connection.HTTPSConnection object at 0x00000216E0D0BE90>: Failed to resolve \'huggingface.co\' ([Errno 11001] getaddrinfo failed)"))'), '(Request ID: 430a9373-6149-47c5-a660-aa1b82df18d3)')' thrown while requesting GET https://huggingface.co/datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl
+2025-05-01 10:34:43,001 - WARNING - Got disconnected from remote data host. Retrying in 5sec [1/20]
+2025-05-01 11:24:41,107 - INFO - Processing source: ncc_newspaper, split: validation
+2025-05-01 11:24:41,121 - INFO - Processing language, split: validation
+2025-05-01 11:26:07,574 - INFO - Documents of ncc_newspaper:
+2025-05-01 11:26:07,575 - INFO - NO: 487086, 73.2081% ; DA: 17516, 2.6326%
+2025-05-01 11:26:07,575 - INFO - After language confidence filtering:
+2025-05-01 11:26:07,577 - INFO - DA: 7632, lost: 56.4284%
+2025-05-01 11:26:07,577 - INFO - Total document change:
+2025-05-01 11:26:07,578 - INFO - 665344 -> 7632, loss: 98.8529%
+2025-05-01 11:26:07,578 - INFO - Assembling whole dataset for filtering
+2025-05-01 11:26:24,562 - INFO - FILTER: ['length_filter']
+2025-05-01 11:26:24,562 - INFO - TOKENS: pre: 669129, post: 661484, loss: 1.14%
+2025-05-01 11:26:24,563 - INFO - DOCUMENTS: pre: 7632, post: 6401, loss: 16.13%
+2025-05-01 11:26:31,510 - INFO - FILTER: ['alpha_filter']
+2025-05-01 11:26:31,511 - INFO - TOKENS: pre: 661484, post: 616869, loss: 6.74%
+2025-05-01 11:26:31,511 - INFO - DOCUMENTS: pre: 6401, post: 5439, loss: 15.03%
+2025-05-01 11:26:37,466 - INFO - FILTER: ['stop_word_filter']
+2025-05-01 11:26:37,467 - INFO - TOKENS: pre: 616869, post: 616059, loss: 0.13%
+2025-05-01 11:26:37,467 - INFO - DOCUMENTS: pre: 5439, post: 5374, loss: 1.2%
+2025-05-01 11:26:38,121 - INFO - Removed 0 duplicate ids
+2025-05-01 11:26:38,129 - INFO - Removed 1 rows with duplicate text
+2025-05-01 11:26:42,145 - INFO - No long texts (>~1e5 tokens) found

data/{ncc/ncc.md → ncc_newspaper/ncc_newspaper.md}

@@ -1,9 +1,9 @@
 ---
-pretty_name: Norwegian Colossal Corpus
+pretty_name: Norwegian Colossal Corpus (newspaper)
 language:
   - da
-license: other
-license_name: CC0 1.0, NLOD 2.0, CC BY-SA 3.0
+license: cc0-1.0
+license_name: CC0 1.0
 task_categories:
   - text-generation
   - fill-mask
@@ -11,16 +11,18 @@ task_ids:
   - language-modeling
 ---
 
-# Dataset Card for Norwegian Colossal Corpus
+# Dataset Card for Norwegian Colossal Corpus (newspaper)
 
 <!-- START-SHORT DESCRIPTION -->
-Danish language subset of [NCC](https://huggingface.co/datasets/NbAiLab/NCC)
+Danish language subset of [NCC](https://huggingface.co/datasets/NbAiLab/NCC) \
+Source: Newspaper articles
 <!-- 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 comes from newspaper articles
 - Document is marked as Danish
 - Confidence of the language classificationis at least 0.5
 - Document has at least 10 words (whitespace separated strings + punctuation)
@@ -33,30 +35,29 @@ This subset is the result of the following filtering from all availabel data spl
 
 <!-- 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
+- **Number of samples**: 5.37K
+- **Number of tokens (Llama 3)**: 1.05M
+- **Average document length (characters)**: 571.69
 <!-- 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",
+  "text": "STOCKHOLM: Det er kommet melding Ul den svenske turlst forenlng om at de to svenske ljellklatrerne s[...]",
+  "source": "ncc_newspaper",
+  "id": "fylkestidendeforsognogfjordane_null_null_19410723_69_54_1_MODSMD_ARTICLE5",
+  "added": "2025-04-30",
+  "created": "1941-01-01, 1941-12-31",
+  "license": "cc0-1.0",
+  "domain": "News",
   "metadata": {
     "source-pretty": "Norwegian Colossal Corpus",
-    "source-type": "maalfrid_regjeringen"
-  }
+    "source-type": "newspaper_ocr"
+  },
+  "__index_level_0__": 0
 }
 ```
 
@@ -72,10 +73,11 @@ An entry in the dataset consists of the following fields:
 - `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/source-type`: (`str`) The exact document identifier from the original data
+- `metadata/*`: Potentially additional metadata
 <!-- END-SAMPLE -->
 
 
+
 ### Dataset Statistics
 
 <!-- START-DATASET PLOTS -->
@@ -83,23 +85,53 @@ An entry in the dataset consists of the following fields:
 <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.
-In this subset of the NCC, license is marked as "other" for the documents, which are under this license. To filter documents with this license, look for:
-  - license == "other"
-  - domain == "Legal"
-  - metadata/source-type == "government*" or "parliament*" or "maalfrid*" or "publireport*" or "lovdata"
-- [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. In this subset of the NCC, license is marked as "other" for the documents, which are under this license. To filter documents with this license, look for:
-  - license == "other"
-  - domain == "Wiki & Books"
-  - metadata/source-type == "wikipedia*"
-
+[CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/)
+
+## Filtering log
+```bash
+2025-05-01 07:46:31,692 - INFO - Loading data from: NbAiLab/NCC
+2025-05-01 07:46:35,756 - INFO - Processing source: ncc_newspaper, split: train
+2025-05-01 07:46:35,757 - INFO - Processing language, split: train
+2025-05-01 09:08:21,490 - INFO - Loading data from: NbAiLab/NCC
+2025-05-01 09:08:35,451 - INFO - Processing source: ncc_newspaper, split: train
+2025-05-01 09:08:35,453 - INFO - Processing language, split: train
+2025-05-01 09:51:35,309 - WARNING - '(MaxRetryError('HTTPSConnectionPool(host=\'huggingface.co\', port=443): Max retries exceeded with url: /datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl (Caused by NameResolutionError("<urllib3.connection.HTTPSConnection object at 0x00000216E0676B40>: Failed to resolve \'huggingface.co\' ([Errno 11001] getaddrinfo failed)"))'), '(Request ID: 8c7cfa56-5cbe-4113-ae0b-9b9192c59c61)')' thrown while requesting GET https://huggingface.co/datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl
+2025-05-01 09:51:35,330 - WARNING - Retrying in 1s [Retry 1/5].
+2025-05-01 09:51:36,342 - WARNING - '(MaxRetryError('HTTPSConnectionPool(host=\'huggingface.co\', port=443): Max retries exceeded with url: /datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl (Caused by NameResolutionError("<urllib3.connection.HTTPSConnection object at 0x00000216EF3EC3E0>: Failed to resolve \'huggingface.co\' ([Errno 11001] getaddrinfo failed)"))'), '(Request ID: 8a52f0ab-4507-4af3-9de8-44600dcbe92b)')' thrown while requesting GET https://huggingface.co/datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl
+2025-05-01 09:51:36,343 - WARNING - Retrying in 2s [Retry 2/5].
+2025-05-01 09:51:38,346 - WARNING - '(MaxRetryError('HTTPSConnectionPool(host=\'huggingface.co\', port=443): Max retries exceeded with url: /datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl (Caused by NameResolutionError("<urllib3.connection.HTTPSConnection object at 0x00000216E0D0B920>: Failed to resolve \'huggingface.co\' ([Errno 11001] getaddrinfo failed)"))'), '(Request ID: 7004c6e6-9238-4ae1-9b2c-625361ec2495)')' thrown while requesting GET https://huggingface.co/datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl
+2025-05-01 09:51:38,347 - WARNING - Retrying in 4s [Retry 3/5].
+2025-05-01 10:34:26,967 - WARNING - '(MaxRetryError('HTTPSConnectionPool(host=\'huggingface.co\', port=443): Max retries exceeded with url: /datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl (Caused by NameResolutionError("<urllib3.connection.HTTPSConnection object at 0x00000216E0D08CE0>: Failed to resolve \'huggingface.co\' ([Errno 11001] getaddrinfo failed)"))'), '(Request ID: e818f8c8-4815-4b64-95f1-1ea5d68005b7)')' thrown while requesting GET https://huggingface.co/datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl
+2025-05-01 10:34:26,976 - WARNING - Retrying in 8s [Retry 4/5].
+2025-05-01 10:34:34,996 - WARNING - '(MaxRetryError('HTTPSConnectionPool(host=\'huggingface.co\', port=443): Max retries exceeded with url: /datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl (Caused by NameResolutionError("<urllib3.connection.HTTPSConnection object at 0x00000216E0D089E0>: Failed to resolve \'huggingface.co\' ([Errno 11001] getaddrinfo failed)"))'), '(Request ID: 3b7514c2-ff9c-4634-b738-535764ff6b86)')' thrown while requesting GET https://huggingface.co/datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl
+2025-05-01 10:34:34,996 - WARNING - Retrying in 8s [Retry 5/5].
+2025-05-01 10:34:43,000 - WARNING - '(MaxRetryError('HTTPSConnectionPool(host=\'huggingface.co\', port=443): Max retries exceeded with url: /datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl (Caused by NameResolutionError("<urllib3.connection.HTTPSConnection object at 0x00000216E0D0BE90>: Failed to resolve \'huggingface.co\' ([Errno 11001] getaddrinfo failed)"))'), '(Request ID: 430a9373-6149-47c5-a660-aa1b82df18d3)')' thrown while requesting GET https://huggingface.co/datasets/NbAiLab/NCC/resolve/857a5832b73ef33c66b5674d970777c39d991c0e/data/train-shard-0010-of-0046.jsonl
+2025-05-01 10:34:43,001 - WARNING - Got disconnected from remote data host. Retrying in 5sec [1/20]
+2025-05-01 11:24:41,107 - INFO - Processing source: ncc_newspaper, split: validation
+2025-05-01 11:24:41,121 - INFO - Processing language, split: validation
+2025-05-01 11:26:07,574 - INFO - Documents of ncc_newspaper:
+2025-05-01 11:26:07,575 - INFO - NO: 487086, 73.2081% ; DA: 17516, 2.6326%
+2025-05-01 11:26:07,575 - INFO - After language confidence filtering:
+2025-05-01 11:26:07,577 - INFO - DA: 7632, lost: 56.4284%
+2025-05-01 11:26:07,577 - INFO - Total document change:
+2025-05-01 11:26:07,578 - INFO - 665344 -> 7632, loss: 98.8529%
+2025-05-01 11:26:07,578 - INFO - Assembling whole dataset for filtering
+2025-05-01 11:26:24,562 - INFO - FILTER: ['length_filter']
+2025-05-01 11:26:24,562 - INFO - TOKENS: pre: 669129, post: 661484, loss: 1.14%
+2025-05-01 11:26:24,563 - INFO - DOCUMENTS: pre: 7632, post: 6401, loss: 16.13%
+2025-05-01 11:26:31,510 - INFO - FILTER: ['alpha_filter']
+2025-05-01 11:26:31,511 - INFO - TOKENS: pre: 661484, post: 616869, loss: 6.74%
+2025-05-01 11:26:31,511 - INFO - DOCUMENTS: pre: 6401, post: 5439, loss: 15.03%
+2025-05-01 11:26:37,466 - INFO - FILTER: ['stop_word_filter']
+2025-05-01 11:26:37,467 - INFO - TOKENS: pre: 616869, post: 616059, loss: 0.13%
+2025-05-01 11:26:37,467 - INFO - DOCUMENTS: pre: 5439, post: 5374, loss: 1.2%
+2025-05-01 11:26:38,121 - INFO - Removed 0 duplicate ids
+2025-05-01 11:26:38,129 - INFO - Removed 1 rows with duplicate text
+2025-05-01 11:26:42,145 - INFO - No long texts (>~1e5 tokens) found
+```
 
 ### Citation Information
 ```

data/{ncc/ncc.parquet → ncc_newspaper/ncc_newspaper.parquet}

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