External reference-based Ocr quality check

A rough quality overview for the documents in the corpus. Uses an external dictionary to count danish tokens in each page, and compares the results to other external sources of alleged "good" quality. Has problems, but is relatively quick and does not require too much resources. Included is a markdown with a more detailed rundown of the process.

.gitattributes

@@ -57,3 +57,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+ocr_metadata/token_count/meta_data.json filter=lfs diff=lfs merge=lfs -text
+ocr_metadata/token_count/ods_fullforms_2020-08-26.csv filter=lfs diff=lfs merge=lfs -text

ocr_metadata/ocr_metadata.md

@@ -0,0 +1,235 @@
+# OCR Meta Data
+
+OCR quality the legibility of scans might not always easy to analyze in a corpus of this magnitude. Especially knowing there are historic texts and at least two different font types present in the original scans.
+
+For assessing the current state of the text data in the corpus and identifying documents which require to be re-processed from the scan a relatively quick, low-resource, rough estimation was used by comparing text meta data to the meta data of external references.
+
+The before comparing to the reference, the pages, that are likely to be noise and/or non-representative to the overall quality of the document, were filtered out.
+
+The meta data of the OCR (and thus text quality) the scripts related to their attainment are available [here](./ocr_metadata.json)
+
+
+The meta data of the texts and the scripts related to their attainment are detailed [here](./token_count/meta_data.json)
+
+
+## Data Fields
+
+An entry in the  ocr_meta_data.json consists of the following fields:
+
+- `filename` (`str`): A unique identifier for each document.
+- `above_ref_line` (`float`): Bounded at [0,1], a numerical representation of quality. The bigger the number, the higher the ratio of pages surpassing the reference line derived from external texts.
+- `processed` (`bool`): Whether the meta data was successfully compared to the reference line.
+- `problem` (`str`): Flagged errors during the comparison process:
+    - `no` : The document was processed, the comparison process ran as expected
+    - `small_doc` :  The document was processed, but the document has less than 10 pages. Low page numbers can influence the outcome of the de-noising.
+    - `no_mix` : The document was processed, but no pages were identified as noisy or non-representative of the whole document. As books usually have at least some empty- or title pages, this level of homogeneity is unexpected.
+    - `low_prop` : The document was processed, but after filtering, the remaining pages were less than half the size of the original document. As books usually have a main type of page, which dominates its majority, (e.g.: pages of full text) this level of variety is unexpected.
+    - `empty` : The document was not processed, the ocr is missing.
+
+## Results and Recommendations
+**Banded quality values by year**
+<p align="center">
+<img src="./plots/ocr_meta_years.png" width="600" style="margin-right: 10px;" />
+</p>
+
+*Ratio and number of documents for each year, if quality is banded into 0.2 chunks based on the `above_ref_line` variable. The dotted line marks 1848*
+
+The plots show a gradual increase in quality of the texts throughout the 19th century. This change in ocr quality likely corresponds to the shift from fraktur to antiqua fonts in book printing. OCR technology available at the time of scanning probably had issues with fraktur based texts. The sudden drop in the number of high-quality OCRs in the early 20th century are simply due to the [public domain filtering](syartide) which removed a lot of documents of ambiguous status before assembling and publishing the corpus itself.
+
+Since the method for determining quality is not without faults (the plots indicate some high-quality OCRs even in the 1750's, which are almost all guaranteed to be in fraktur) the year 1848 seems to be an adequate dividing line. 
+
+Documents published from this year onward with a high `above_ref_line` value should be of acceptable quality, while the rest might require either some text restoration or more OCR methods. But as the examples show, all documents should be approached cautiously.
+
+Pre 1848 excerpts with `above_ref_line` of 1:
+<details>
+<summary>Disse Rigers Fortrin i Lyksali... (1752)</summary>
+1te Crearur, fi>m hav formeeret Naturens Rige med et L iv , har Ud­
+rettet meere end de, som ikke ere S tore uden ved Adeleggelse.
+Forend Throner og M e re  bleve besmittede med B lo d ; forend 
+Hyklerie og Overtros bragte den Lårdom ind, at M agten ikke var 
+bundet ril Viisdom s Lov, da i den lyksalige Alder saae man de adel- 
+modige Helte at bane sig Vey til et ubodeligt N avn ved at vare det 
+menneskelige Kions Lovgivere, Velgiorere og Beskyttere: A t giore 
+Jorden frugtbar, sormeere Landet med S tader og Indbyggere, be­
+fordre mange Familiers Velstand ved Handel og Konster, og giore 
+deres Lyksalighed sikker og bestandig ved Love var den eeneste V ey til 
+DLre og Udsdelighed: D e  forte ikke S v a rd e t, uden for at hanthave de 
+viise Love, som de selv havde givet, og fo ra t stadfaste Folket i en ro­
+lig Besiddelse a f den Lyksalighed, hvortil de selv vare forste Aarsag og 
+S tifte re . 
+</details>
+<details>
+<summary>Et ringe Bryllups-Digt, da Bru... (1753)</summary>
+O ! et lyksaligt P a r, hvor Venskab saa kand fryde,
+Hvor ZEgte-Folk ey Tab paa noget godt stal nyde,
+Hvor parret P ar sin Fryd ey finder uden der,
+Hvor deres Hjemme - Sted i TEgte-Pagten er.
+Men er det saa, saa er'vel den, der ugift bliver,
+Ey saa lyksalig, som ben Mand, der sig hengiver 
+T>'l stig en Engle- V en, og faaer den Mage, der 
+Fornoyer, elsker og ham årer med l?lsiler.
+V or B r u d g o m  har ved sit eomxali ven Havn tiltragtet 
+Han fem Aars S oe-fart mod sligt Haab har lidet ag tet/ 
+Som  Soe-Mand bcrr han P riis, nu Reysen vel er endt, 
+V or erdle Brudgom ^  oredi Sorg til Trsst blev sendt.
+</details>
+<details>
+<summary>Kort Samtale imellem en Landma...(1760)</summary>
+Deres Hoygrevelige Excellencer,
+Hr. Johan Ludvig von HMlil,
+Greve til Detln-aborg, Ridder a f Dlepkanten, Geheime Raad t 
+det Geheime < I!onleil, Cammerherre, Ober-8eeret3ir i det Danffe
+(dancellie, krLlidi Udi d!o!legio de Ourlu D vangelu promovendo, 
+(Jeneral-KirkednlpeLkori, og krXddi i det Kongelige Viden­
+skabernes 8oeietXt udi Kiobenhavn rc.
+</details>
+
+___
+
+Excerpts from 1848 with `above_ref_line` of 1:
+<details>
+<summary>Kongens Svar og dets Følger</summary>
+^ndskjondt vi ikke tröste os til ved Ordet at gribe ind i Be­
+givenhedernes Gang, saa ville vi dog ikke svigte det Hverv at 
+oplyse Veien for Villien, der aldrig behover mere Lys end naar 
+Folelsen stcerkt opliver den. 
+Kongen har talt; og hver dansk Mand slutter sig nu til 
+ham. Kongens Svar til det tydffe Parties Assendinge er i Alles 
+Mund, — og, hvilke Anskuelser man end iovrigt hvlder, saa 
+vil Enhver tilstaae, at der er Forstand med Kraft i den Tale. 
+</details>
+<details>
+<summary>Pastor Hieronimus Laubs Efterm...</summary>
+3S 
+aaudrig, talentfuld og begavet Religionslærer; en tw 
+Hyrde for den ham anbetroede Hjord, der ikke plejede 
+denne med menneskelig Viisdoms svulstige Ord, men 
+prcedikede som' en sand Herrens Apostel Guds Ord reent 
+og pnurt, og agtede hverken sig selv eller Menigheden 
+at vide Andet til Salighed end Jesum Christum, og 
+ham korsfæstet; hvorfor han og kunde sige sig selv med 
+Apostelen: „Det er min Roes, min Samvittigheds 
+Vidnesbyrd, at jeg har vandret for Gud i Oprigtighed 
+og Hjertets Retsindighed". 
+</details>
+<details>
+<summary>Sørgetale ved Kong Christian d...</summary>
+Kongernes Konge, Du Herrernes Herre! 
+Dybt boie vi os for Dig, som holder Almagtens 
+Scepter i DinHaand; men i det vi boie os for 
+Dig med dybeste LErefrygt, hceve vi ogsaa Blikket 
+til Dig med den barnligste Tillid, fordi vi vide, 
+at Du, paa hvis Vink Troner henveires og 
+Herskerspire knuses, er Algodhedens Gud, som 
+Du er Alvceldens. Men derfor tor vi ogsaa for 
+Dig, barmhjertige Fader, udtale vore Klager,
+</details>
+
+___
+
+# Methods  
+The processes for estimating quality are detailed below 
+
+## Reference Data and Comparison
+For reference, 10k documents were sampled from the [Enevaldens nyheder](https://huggingface.co/datasets/danish-foundation-models/danish-dynaword/tree/main/data/enevaeldens_nyheder) dataset from the [Danish Dynaword](https://huggingface.co/datasets/danish-foundation-models/danish-dynaword). That dataset is assumed to have similar linguistic and stylistic contents, as it is also a collection historic Danish writings, dating back multiple centuries.
+
+The Danish Dynaword in addition, has an automatic labeling process, which can assess text quality.
+
+Only documents with the "good" label were chosen, to try and assemble a reference dataset.
+ 
+
+The 10k documents were processed in the same way as the meta data of this corpus. The texts were tokenized, and tokens were matched to entries in the [reference dictionary](szartide).
+The `text_rel_a_words` (float) variables were extracted, which are all These are all bounded \[0,1\]. These values formed a reference distribution, with each value in it representing the ratio of identifiable danish words and all words in a single text from an allegedly good quality historic Danish dataset. The median of this distribution was chosen as the **reference line**.
+
+To determine the ocr quality of the documents of this corpus, the `text_rel_a_words` values for each document were also extracted from the metadata and compared to the **reference line**. 
+
+The comparison resulted in the `above_ref_line`(float) variable bounded \[0,1\], which represents the proportion of pages in the document, that were above the reference line. A value of 1 would therefore mean a document in which all pages had a greater proportion of \( tokens found within the dictionary / all alphabetical tokens \) than the reference line. This would probably indicate a document with a high high-quality OCR.  
+Values around 0.5 would indicate ambiguous, but possibly similar quality to the historic texts, and values of 0 would indicate worse quality.  
+
+Relevant scripts for producing the reference values are available [here](./scripts/get_ref_median.py).  
+Relevant scripts for comparison to the reference values are available [here](./scripts/doc_quality.py). 
+
+## Removing Noise
+
+The exact contents of the documents are also quite important and can influence the results. The reference distribution contains values derived from only text, while a page in this scanned corpus might be empty, might have pictures or only a small amount of tokens. For example, because of this, a picture book with perfectly legible, high-quality OCR scan danish text, which is above the reference line but only on every odd page, because even pages have pictures and therefore 0 alphabetical tokens, would have a final value of 0.5. This could prove problematic and lead to false estimations in the OCR quality of some documents. Also, if one thinks of books, they usually have empty pages in the front, back and between chapters, or might have title pages with only named entities, etc. These would all lower the estimated quality, therefore there needs to be a way to separate the relevant pages of every document. The pages which hold the majority of text contents and therefore would be the best indication of quality.
+
+### Conjugate prior based poisson mixture estimation  
+
+A non parametric conjugate-prior based mixture estimation was used to determine which pages are representative for each document.
+
+If a book is a collection of different page types, e.g. pages with only text, pages with half text, title and empty pages, it could modelled as a mixture of discrete distributions, where each discrete value corresponds to the number of tokens on a page. These distributions are supposed to be clearly separable when ordered, and there should be minimal overlap between the drawn values.   
+
+Therefore a poisson mixture model could probably clearly separate the underlying page types for each document, but to avoid the use of more complex modeling techniques, the pages were simply ordered and treated as individual draws from poisson distributions, while a gamma distribution, which is the conjugate prior for the poisson, was calculated after every observation. This way, the gamma distribution gives the expected values for the lambda value of the poisson. In case the new value will be much higher than expected, the expectations of the gamma distribution will greatly update, and this signals that these are now drawn from a new poisson distribution. 
+It is important for this to work, that the pages are ordered by the number of words on them in an increasing fashion.
+
+The method is crude and might not be as precise as a mixture model estimation, but at least, it is fast and the only essential external library for running it is [numpy](https://numpy.org/).
+
+Then after mixture boundaries were identified, the number of pages belonging to each category were counted, and the one with the most pages in it was deemed the representative distribution for that document. Other noisy or non-related pages were filter out before comparing the documents to the **reference line**.
+
+Relevant scripts for filtering the pages is available [here](./scripts/find_rep_pages.py).  
+Error logs during filtering are available [here](./scripts/repr_meta.log)
+
+
+### Mixture Separation Example 
+There is a 100 page document which is a mixture of draws from 3 [poisson](https://en.wikipedia.org/wiki/Poisson_distribution) distributions.  
+
+|Distributions  |         ||# draws | 
+|------------|---------|---|--| 
+| **$\lambda_{noise}$** | 10| |5| 
+| **$\lambda_{picture}$** | 80| |15| 
+| **$\lambda_{text}$** | 200| |80| 
+
+If the pages are ordered, the first 5 will be from a poisson with $\lambda_{noise}$. Let these values be \[  8,   8,  12,  13,  15 \].
+
+The [gamma](https://en.wikipedia.org/wiki/Gamma_distribution) distribution is the conjugate prior of the [poisson](https://en.wikipedia.org/wiki/Poisson_distribution), meaning, after each $n^{th}$ draw of $x$ from a poisson, the expected possible **$\lambda_{n+1}$** values can be modelled as: 
+$$ 
+\alpha_{n+1} = \sum_{i=1}^{n} x_i \qquad \beta_{n+1} = n \qquad \lambda_{n+1} \sim Gamma(\alpha_{n+1},\beta_{n+1})
+$$
+
+So after page 1 \(page 1 here refers not to original page 1, but the one with the least words on it after ordering\)
+$$
+\lambda_{2} \sim Gamma(8,1)
+$$
+After page 2:  
+$$
+\lambda_{3} \sim Gamma(8+8,2)
+$$
+And so on...  
+$$
+\lambda_{4} \sim Gamma(28,3) \\
+\lambda_{5} \sim Gamma(41,4) \\
+\lambda_{6} \sim Gamma(56,5) \\
+$$
+
+But after page 5, there is a big change, because the currently expected gamma has a mean of $56/5 = 11.2$ but we know in this case the next 15 pages are drawn from $\lambda_{picture}$, which is $80$.
+
+While the conjugate prior gamma for $\lambda$ was slowly homing on the value 10, now it will have a large update.
+
+Let's say that $x_6 = 63$
+$$
+\lambda_{7} \sim Gamma(119,6)
+$$
+
+
+This is an observable difference. The mean of this distribution is $19.83$. Then the conjugate prior estimated lambda values for the second distribution will "clump" together again, until $x_{21}$ is reached, where there will be another big leap in the expected possible values for $\lambda_{22}$. 
+
+To automatically identify the leaps, the second derivative of the means of the gamma distributions were taken.
+This way, large changes will emerge as outlier positive numbers. For example:
+
+$$
+\{x_i \mid 1 \leq i \leq ...\} = \{8,8,12,13,15,63,65, ...\} \\[10pt]
+\mu_{gammas} =  \{8,8,9.33, 10.25, 11.2,19.83, 26.28,...\}\\[10pt]
+\Delta^2 \mu_{gammas} = \{ 1.33, -0.41,  0.03,  7.68, -2.46,...\}
+$$
+
+To make this a non parametric estimation, outliers in this list are treated as borders between different distributions. Preferably, values above the mean by 3 standard deviation were treated as outliers.
+
+<p align="center">
+<img src="./plots/example_denoiseing.png" width="600" style="margin-right: 10px;" />
+</p>
+
+In the case of this simulated example, it successfully identified the 3 different distributions, but with smaller difference between the lambdas, or too small overall document size,this method might struggle. 
+
+
+
+

ocr_metadata/scripts/doc_quality.py

@@ -0,0 +1,110 @@
+from datasets import Dataset, load_dataset, disable_progress_bars, concatenate_datasets
+
+from tqdm import tqdm
+
+from page_mix import *
+
+import re
+disable_progress_bars()
+
+def update_processed_docs(ds,document,msg):
+    #save current problem, if 
+    if ds["problem"] == "no":
+        old_p = ""
+    else:
+        old_p = ds["problem"]
+
+    if ds["filename"] == document:
+        ds.update({"problem":old_p + msg})
+    else:
+        pass
+    return ds
+
+def empty_docs(documents):
+    ds=[]
+    for i in documents:
+        ds.append({"filename":i,"above_ref_line":0.0,"processed":False,"problem":"empty"})
+    ds = Dataset.from_list(ds)
+
+    return ds
+
+
+def main():
+    quality_list = []
+
+    #assemble dataset from representative pages
+    meta_data = load_dataset("./repr_meta",split="train")
+    #get reference line to from "good quality" documents
+    #by taking the median of its alphabetic character ratio dist
+    ref_docs = Dataset.from_parquet("good_qual_10k_counts.parquet")
+    reference_line = np.median(ref_docs["text_rel_a_words"])
+
+
+    #separate years
+    year_list = sorted(list(set(meta_data["published"])))
+
+    for year in tqdm(year_list,desc="YEARS "):
+
+        #filter each year
+        year_meta_data = meta_data.filter(lambda ds,year:ds["published"] == year, num_proc= 10, fn_kwargs={"year":year})
+
+        document_list = sorted(list(set(year_meta_data["file_name"])))
+
+        for document in tqdm(document_list,
+                                leave=False,
+                                desc="DOCS "):
+            
+            #compare page alphabethic ratios to ref line
+            doc_meta_data = year_meta_data.filter(lambda ds,document:ds["file_name"] == document, fn_kwargs={"document":document})
+
+            rp = compare_to_ref_line(doc_meta_data,
+                                     ref_val=reference_line,
+                                     column_to_compare="page_text_rel_a_words")
+            #assigning for inspection
+            quality_list.append({"filename":document,"above_ref_line":rp,"processed":True,"problem":"no"})
+
+    #create dataset
+    quality_ds = Dataset.from_list(quality_list)
+
+    ######
+    #Error docs
+    with open("./repr_meta.log") as f:
+        lines = f.readlines()
+
+    re_pat= r"ERROR:.*pdf"
+   
+    epe = [i for i in lines if "EmptyDocumentError" in i]
+    nme = [i for i in lines if "NoMixError" in i]
+    lpe = [i for i in lines if "LowProportionError" in i]
+    small_doc = [i for i in lines if "small_doc:True" in i]
+
+    #pair the errors with filenames
+    nme_fns = [re.findall(re_pat,i)[0].replace("ERROR: ", "") for i in nme]
+
+    epe_fns = [re.findall(re_pat,i)[0].replace("ERROR: ", "") for i in epe]
+
+    lpe_fns = [re.findall(re_pat,i)[0].replace("ERROR: ", "") for i in lpe]
+
+    small_doc_fns = [re.findall(re_pat,i)[0].replace("ERROR: ", "") for i in small_doc]
+
+    #append vals from logs
+    for i in tqdm(small_doc_fns,leave=False,desc="small_docs"):
+        quality_ds = quality_ds.map(update_processed_docs,fn_kwargs={"document":i,"msg":"small_doc;"})
+
+    for i in tqdm(nme_fns,leave=False,desc="no_mix"):
+        quality_ds = quality_ds.map(update_processed_docs,fn_kwargs={"document":i,"msg":"no_mix;"})
+
+    for i in tqdm(lpe_fns,leave=False,desc="low_prop"):
+        quality_ds = quality_ds.map(update_processed_docs,fn_kwargs={"document":i,"msg":"low_prop;"})
+
+    empty_document = empty_docs(epe_fns)
+
+    quality_ds = concatenate_datasets([quality_ds,empty_document])
+    #print(epe_fns)
+    
+    #save results
+    quality_ds.to_json("../ocr_metadata.json")
+
+            
+if __name__ == "__main__":
+    main()

ocr_metadata/scripts/find_rep_pages.py

@@ -0,0 +1,79 @@
+import os
+import logging
+
+from datasets import Dataset , concatenate_datasets, disable_progress_bars
+from tqdm import tqdm
+
+from u_func import *
+from page_mix import *
+
+
+
+logging.basicConfig(filename="repr_meta.log",
+                    format='%(asctime)s %(levelname)s: %(message)s',
+                    filemode='a')
+
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+def main():
+    logger.info("START...")
+    disable_progress_bars()
+
+    #metadata
+    meta_data = Dataset.from_json("../token_count/meta_data.json")
+    #separate years
+    year_list = sorted(list(set(meta_data["published"])))
+
+    for year in tqdm(year_list,desc="YEARS "):
+        logger.info(f"{year} : ")
+        year_ds_list = []
+        #filter each year
+        year_meta_data = meta_data.filter(lambda ds,year:ds["published"] == year, num_proc= 10, fn_kwargs={"year":year})
+
+        #separate documents
+        document_list = sorted(list(set(year_meta_data["file_name"])))
+
+        for document in tqdm(document_list,
+                            leave=False,
+                            desc="DOCS "):
+
+
+            doc_meta_data = year_meta_data.filter(lambda ds,document:ds["file_name"] == document, fn_kwargs={"document":document})
+
+            if len(doc_meta_data)<10:
+                small_doc = True
+            else:
+                small_doc = False
+
+            #remove first page (it is a cover by the library, and not part of the ocr)
+            doc_meta_data = doc_meta_data.filter(lambda ds: ds["page_id"][-3:] != "_p1")
+            #find the pages which are more representative of the whole ocr
+            #meaning they have no outlier amount of tokens
+            doc_toks = list(doc_meta_data["page_text_n_tokens"])
+
+            try:
+                doc_meta_data = doc_meta_data.filter(representative_pages,
+                                        fn_kwargs={"doc_toks":doc_toks,
+                                                "column":"page_text_n_tokens"})
+            except (EmptyDocumentError,NoMixError,LowProportionError) as e:
+                logger.error(f"{document} problem, small_doc:{small_doc} ,{e}")
+                if "EmptyDocumentError" in e.message:
+                    continue
+                else:
+                    #if no denoizing could be done, mark all pages as representative, the problem is logged
+                    pass
+
+            #temporary ds added to to large ds
+            year_ds_list.append(doc_meta_data)
+
+        #save by year
+        year_ds = concatenate_datasets(year_ds_list)
+        fp = os.path.join(".","repr_meta",f"{year}_pages.json")
+        year_ds.to_json(fp)
+
+if __name__ == "__main__":
+    main()
+
+
+

ocr_metadata/scripts/get_ref_median.py

@@ -0,0 +1,36 @@
+from datasets import load_dataset, Dataset
+
+import pandas as pd
+from u_func import *
+from page_mix import *
+
+
+def main():
+    #get reference data of acceptable quality
+    #load dynaword metadata and filter good quality texts
+    meta = load_dataset("danish-foundation-models/danish-dynaword", "meta", split="train").filter(
+    lambda row: (row["dataset"] == "enevaeldens_nyheder") & (row["content_quality"] == "good"), num_proc = 10,
+    )
+    #select 10k docs
+    good_quality_ids = [i for i in meta["id"][:10000]]
+    #load dynaword texts and filter good quality texts
+    a = load_dataset("danish-foundation-models/danish-dynaword", "enevaeldens_nyheder", split = "train").filter(
+    lambda ds, good_quality_ids: ds["id"] in good_quality_ids,
+    fn_kwargs={"good_quality_ids":good_quality_ids},
+    num_proc=10)
+
+    #load in wordset to check against
+    danish_words=list(pd.read_csv("../token_count/ods_fullforms_2020-08-26.csv", sep  = "\t")["A"])
+    danish_words = [i.lower() for i in danish_words]
+    danish_words = list(set(danish_words))
+
+    b = a.map(
+        count_tokens_and_words,
+        fn_kwargs = {"colname":"text",
+                        "wordlist":danish_words},
+                        num_proc = 10)
+
+    b.to_parquet("good_qual_10k_counts.parquet")
+
+if __name__ == "__main__":
+    main()

ocr_metadata/scripts/good_qual_10k_counts.parquet

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

ocr_metadata/scripts/page_mix.py

@@ -0,0 +1,160 @@
+import warnings
+
+import numpy as np
+
+
+def estimate_groups_sd(data:list[int]) -> list[list[int],list[str]]:
+    """ Estimates a multiple poisson model mixture by finding large changes in conjugate priors updates. """
+
+    if 0 in data:
+        warnings.warn("WARNING : 0s. Make sure missing (0) observations are in the assumptions")
+    else:
+        pass
+
+    #we have a range of n_toks
+    n_toks = sorted(data)
+    #take cumulative sum
+    cs_toks = np.cumsum(n_toks)
+
+    #calculate conjugate prior updates
+    # alpha_i+1 = alpha_i + k
+    # beta_i+1 = beta_i + 1
+
+    mean_list = [(cs_toks[idx_i])/(idx_i + 1) for idx_i, i in enumerate(n_toks)]
+    #############################################
+    #differences 
+    diff_diff = np.diff(mean_list, n=2)
+    # find borders, to big changes
+    # find outliers, assume gaussian?
+    m =np.mean(diff_diff)
+    s = np.std(diff_diff)
+    out_limit = m+3*s
+  
+    #find the id of the borders
+    border_idx = np.where(diff_diff > out_limit)[0]
+    if len(border_idx) == 0:
+        out_limit = m+2*s
+        border_idx = np.where(diff_diff > out_limit)[0]
+        warnings.warn("StdLoweredWarning: Outlier detection was lowered to 2 standard deviations range. Data might have too few observations, or the difference in the counts could have an unexpected linear increase")
+    if len(border_idx) == 0:
+        out_limit = m+1*s
+        border_idx = np.where(diff_diff > out_limit)[0]
+        warnings.warn("StdLoweredWarning: Outlier detection was lowered to 1 standard deviations range. Data might have too few observations, or the difference in the counts could have an unexpected linear increase")
+    if len(border_idx) == 0:
+        warnings.warn("NoMixWarning: No clear borders found. Data might have too few observations, or the difference in the counts could have an unexpected linear increase")
+    # + 2 cause the differentiation lessens the length and we want
+    # the border idx to be the first value of the group on the discrete data
+    borders = [n_toks[i+2] for i in border_idx]
+    #############################################
+    #make bins on the original data
+    indices = np.digitize(data, borders, right=False)
+
+    return (data,indices,borders)
+
+def category_overview_sd(data_list):
+    #separate to category
+    _, og_groups, borders = estimate_groups_sd(data_list)
+    #
+    group_ids, group_count =np.unique(og_groups,return_counts=True)
+    group_count = group_count / len(data_list)
+
+    borders = [0] + borders
+
+    overview_dict = np.array([group_ids,group_count,borders])
+    return overview_dict
+
+
+
+def beta_median(alpha:int,beta:int):
+    """ Approximates beta median based on :
+
+    Kerman, J. (2011). A closed-form approximation for the median of the beta distribution (arXiv:1111.0433). arXiv. https://doi.org/10.48550/arXiv.1111.0433
+    """
+    b_med = (alpha-(1/3))/(alpha+beta-(2/3))
+    return b_med
+
+def estimate_beta_median(n_toks:int,n_correct:int):
+    if n_toks == n_correct:
+        warnings.warn("WARNING: all tokens are identified, n_correct will be decreased by one")
+        n_correct = n_correct - 1
+    
+    assert n_toks > 1, f"ERROR: few tokens on page: {n_toks}, n_toks should be > 1"
+    assert n_correct >1,f"ERROR: Too few identified tokens on page: {n_correct}, n_correct should be > 1"
+
+    n_incorrect = n_toks - n_correct
+    return beta_median(n_correct,n_incorrect)
+
+def estimate_median_diff(medians_1:list[float], medians_2:list[float]):
+    """ Estimate the probability of the second set of medians being higher than the first. Median ids should align"""
+
+    assert len(medians_1) == len(medians_1), f"ERROR: mismatch in median list sizes: m1: {len(medians_1)}, m2: {len(medians_1)}"
+
+    med_diff = np.array(medians_2) - np.array(medians_1)
+
+    return np.mean(med_diff > 0)
+
+#################################for filtering huggingface datasets
+
+#custom errors to handle different unexpected values
+class EmptyDocumentError(Exception):
+    def __init__(self, message = "EmptyDocumentError : Pages with tokens too low"):
+        super().__init__(message)
+        self.message = message
+
+    def __str__(self):
+        return f"{self.message}"
+
+class NoMixError(Exception):
+    def __init__(self, message = "NoMixError : No clear boundaries have been found. Leaps in page differences might be strangely linear. "):
+        super().__init__(message)
+        self.message = message
+
+    def __str__(self):
+        return f"{self.message}"
+    
+class LowProportionError(Exception):
+    def __init__(self, message = "LowProportionError : The highest proportion for representative pages is less than 0.5. There might be too few pages or leaps in page differences might be strangely linear."):
+        super().__init__(message)
+        self.message = message
+
+    def __str__(self):
+        return f"{self.message}"
+
+#filter representative category
+def representative_pages(ds,doc_toks,column:str):
+    #og len
+    l1 = len(doc_toks)
+    doc_toks_non_0 = [i for i in doc_toks if i !=0]
+
+    if len(doc_toks_non_0) / l1 < 0.2:
+        raise EmptyDocumentError(f"EmptyDocumentError : Pages with tokens: {len(doc_toks_non_0)}, Total pages: {l1}")
+    
+    catover = category_overview_sd(doc_toks)
+
+    #border value for category with the highest proportion in the data 
+    max_proportion = np.max(catover,axis=1)[1]
+    max_prop_cat = np.where(catover[1]==max_proportion)[0][0]
+    cat_lb = catover[2][max_prop_cat]
+
+    if len(catover[0]) == 1:
+        raise NoMixError()
+    if max_proportion < 0.5:
+        raise LowProportionError()
+
+    
+    #if the highest category is the most likely
+    #is the most likely only get min,
+    #otherwise get the border of the next category too
+    if (np.max(catover,axis=1)[0] == max_prop_cat):
+        val = (ds[column] >= cat_lb)
+
+    else:
+        next_cat = max_prop_cat+1
+        cat_ub = catover[2,next_cat]
+        val = (ds[column] >= cat_lb) & (ds[column] < cat_ub)
+    
+    return val
+
+def compare_to_ref_line(dataset,ref_val:float,column_to_compare:str):
+    ratio_of_pass = np.mean(np.array(dataset[column_to_compare]) > ref_val)
+    return ratio_of_pass

ocr_metadata/scripts/page_mix_plots.py

@@ -0,0 +1,105 @@
+import warnings
+
+import numpy as np
+import pandas as pd
+
+#import pymc as pm
+from plotnine import *
+
+
+def estimate_groups_plot(data:list[int],std:int=3) -> list[list[int],list[str]]:
+    """ Estimates a multiple poisson model mixture by finding large changes in conjugate priors updates. """
+
+    if 0 in data:
+        warnings.warn("WARNING : 0s detected in input data, this could result in more groups being estimated than expected. Make sure missing (0) observations are in the assumptions")
+    else:
+        pass
+
+    r_gen = np.random.default_rng()
+
+    #we have a range of n_toks
+    n_toks = sorted(data)
+    #take cumulative sum
+    cs_toks = np.cumsum(n_toks)
+
+    d_list = []
+    mean_list= []
+
+    for idx_i, i in enumerate(n_toks):
+
+        #alpha and beta values for the gamma dist
+        alpha=cs_toks[idx_i]
+        beta=idx_i + 1
+        mean_list.append(alpha/beta)
+
+        draws = r_gen.gamma(shape=alpha, scale = 1/beta,size=100)
+        #draws = pm.draw(pm.Gamma.dist(alpha=alpha,
+        #                            beta=beta),100)
+        
+        for d in draws:
+            d_list.append({"n_toks":i,"gamma_a":alpha,"gamma_b":beta,"val":d, "m":mean_list[idx_i]})
+
+    df = pd.DataFrame(d_list)
+
+    #############################################
+    #differences 
+    diff_diff = np.diff(mean_list, n=2)
+    # find borders, to big changes
+    # find outliers, assume gaussian?
+    m = np.mean(diff_diff)
+    s = np.std(diff_diff)
+
+    out_limit = m+std*s
+    outliers = [i for i in diff_diff if i>out_limit]
+
+    #if no outliers, start inflating with zeros
+
+
+    #find the id of the borders
+    border_idx = np.where(diff_diff > out_limit)[0]
+
+    # + 2 cause the differentiation lessens the length and we want
+    # the border idx to be the first value of the group on the discrete data
+    borders = [n_toks[i+2] for i in border_idx]
+
+    #find the id of those outliers to visualize the prior updates
+    prior_borders = [mean_list[i+2] for i in border_idx]
+    #############################################
+    #visualize original dists
+
+    #value category labels, as many as identified borders
+    labels = np.array([f"group_{i}" for i in range(len(borders)+1)])
+
+    #make bins
+    indices = np.digitize(n_toks, borders, right=False)
+    cats = labels[indices]
+
+    recat = [{"n_toks": i, "cat":cats[idx_i]} for idx_i, i in enumerate(n_toks)]
+
+
+    #plot differences?
+    vis_diff = pd.DataFrame(diff_diff,columns=["val"])
+
+
+    recat_df = pd.DataFrame(recat)
+    
+    plot = (
+        ggplot(df,aes("val",group="n_toks"))
+        + geom_vline(xintercept=prior_borders, linetype="dashed")
+        + xlab("expected lambda values after each page")
+        + geom_density()
+        + theme_classic()
+    ) / (
+        ggplot(vis_diff,aes("val"))
+        + geom_density()
+        + geom_vline(xintercept=outliers,linetype="dashed")
+        + xlab("outliers in the gamma means (second derivatives)")
+        + theme_classic()
+    ) / (
+        ggplot(recat_df,aes("n_toks",fill="cat"))
+        + geom_vline(xintercept=borders, linetype="dashed")
+        + xlab("separated distributions")
+        + geom_density()
+        + theme_classic()
+    )
+    return plot

ocr_metadata/scripts/u_func.py

@@ -0,0 +1,185 @@
+import itertools
+from collections import Counter
+from datasets import Dataset
+
+from tqdm import tqdm
+
+def only_nan(input:list) -> bool:
+    #remove nans and whitespaces
+    c_input = [e for e in input if e==e and e!=" "]
+    if len(c_input) > 0:
+        return False
+    else:
+        return True
+
+def shard_ds(ds:Dataset, size=1000) -> list[Dataset]:
+    if len(ds) < 1000:
+        ds_list = [ds]
+    else:
+        ds_list = []
+        n_s = round(len(ds)/size)
+        indices = [i for i in range(n_s)]
+        for i in indices:
+            data_shard = ds.shard(num_shards=n_s, index = i)
+            ds_list.append(data_shard)
+    
+    return ds_list
+
+
+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} ")
+    t = text.split()
+    return t 
+
+def remove_punkt_and_numbers(tokens:list[str]) -> list[str]:
+    punkt = [",", ".", "!", "?", ":", ";", "(", ")", "[", "]", "{", "}", '"', "'"]
+    tokens = [i.lower() for i in tokens if i not in punkt and i.isalpha()]
+    return tokens
+
+
+def count_tokens_and_words(page:Dataset,colname:str,wordlist:list[str])-> Dataset:
+    """returns all token count including numbers and punctuation,
+    as well as relation of dictionary items to all tokens (measures general quality),
+    and relation of dictionary items to only alphabetic words (measures difference between ocr methods)
+    """ 
+
+    toks = word_tokenize(page[colname])
+    a_toks = remove_punkt_and_numbers(toks)
+    t_length = len(toks)
+
+    punkt = [",", ".", "!", "?", ":", ";", "(", ")", "[", "]", "{", "}", '"', "'"]
+    t_punkt = [i for i in toks if i in punkt]
+    n_punkt = len(t_punkt)
+
+    word_c = [i for i in a_toks if i in wordlist]
+    if len(a_toks) == 0:
+        wc_rel = 0.0
+        wc_a_rel = 0.0
+    else:
+        wc_rel = round(len(word_c)/len(toks),4)
+        wc_a_rel = round(len(word_c)/len(a_toks),4)
+
+    t_name = colname + "_n_tokens"
+    wc_name = colname + "_rel_words"
+    wc_a_name = colname + "_rel_a_words"
+    p_t_name = colname + "_punkt_tokens"
+    a_t_name = colname + "_a_tokens"
+
+    page.update({t_name:t_length,
+                 wc_name:wc_rel,
+                 wc_a_name:wc_a_rel,
+                 p_t_name:n_punkt,
+                 a_t_name:len(a_toks)})
+    
+    return page
+
+def all_possible_words(word:str,ed:dict[str:list[str]]):
+    """returns a list of all possible words based on the most common misidentification errors for characters"""
+
+    pc_at_idx = []
+    #for each character
+    for char in word:
+        if char in ed.keys():
+            #check if that character has possible errors
+            possible_chars=ed.get(char)
+            pc_at_idx.append(possible_chars)
+        
+        else:
+            pc_at_idx.append([char])
+    #get all combinations of possible error characters without dups
+    a = list(set(itertools.product(*pc_at_idx)))
+    alternate_word_list = ["".join(list(i)) for i in a] 
+    return alternate_word_list
+
+def error_checker(a_toks:list[str],wordlist:list[str],errors:dict[str,list[str]]):
+    """If token is not in the wordlist, tries the possible misidentified characters to lessen the errors"""
+    word_c = []
+    for alpha_token in tqdm(a_toks):
+        #only check against specific starting chars???
+
+            
+        ##
+        if alpha_token in wordlist:
+            word_c.append(alpha_token)
+            #limit lenght otherwise time explodes
+        elif len(alpha_token)<7:
+            a_p_w = sorted(all_possible_words(alpha_token,errors))
+            # limit what to check against based on first char
+            # slice x subsets from wordlsit based on only the first character
+            c_keys= Counter(a_p_w).keys()
+            abc_wl = [[i for i in wordlist if i[0] == j] for j in c_keys]
+
+            for alternate_w in a_p_w:
+                #determine which abc_wl to check against
+                abc_idx = list(c_keys).index(alternate_w[0])
+
+                if alternate_w in abc_wl[abc_idx]:
+                    word_c.append(alternate_w)
+                    break
+                else:
+                    pass
+        else:
+            pass
+    return word_c
+            
+
+
+def count_tokens_and_words_2(page:Dataset,
+                             colname:str,
+                             wordlist:list[str],
+                             err_dict:dict[str,list[str]])-> Dataset:
+    """returns all token count including numbers and punctuation,
+    as well as relation of dictionary items to all tokens (measures general quality),
+    and relation of dictionary items to only alphabetic words (measures difference between ocr methods)
+    """ 
+    toks = word_tokenize(page[colname])
+    a_toks = remove_punkt_and_numbers(toks)
+    t_length = len(toks)
+
+    punkt = [",", ".", "!", "?", ":", ";", "(", ")", "[", "]", "{", "}", '"', "'"]
+    t_punkt = [i for i in toks if i in punkt]
+    n_punkt = len(t_punkt)
+    #now here someting that checks all possible errors
+    word_c = error_checker(a_toks,wordlist,err_dict)
+
+    
+    if len(a_toks) == 0:
+        wc_rel = 0.0
+        wc_a_rel = 0.0
+    else:
+        wc_rel = round(len(word_c)/len(toks),4)
+        wc_a_rel = round(len(word_c)/len(a_toks),4)
+
+    t_name = colname + "_n_tokens"
+    wc_name = colname + "_rel_words"
+    wc_a_name = colname + "_rel_a_words"
+    p_t_name = colname + "_punkt_tokens"
+    a_t_name = colname + "_a_tokens"
+
+    page.update({t_name:t_length,
+                 wc_name:wc_rel,
+                 wc_a_name:wc_a_rel,
+                 p_t_name:n_punkt,
+                 a_t_name:len(a_toks)})
+    
+    return page
+
+
+def make_year_list(start_year: int, stop_year: int) -> list[str]:
+    """make a list of file names based on years"""
+    year_list = list(range(start_year, stop_year + 1))
+    year_list = [str(i) for i in year_list]
+    return year_list

ocr_metadata/token_count/make_count.py

@@ -0,0 +1,109 @@
+# /// script
+# requires-python = "==3.12"
+# dependencies = [
+#     "huggingface-hub>= 0.34.4"
+#     "datasets>=3.5.0",
+# ]
+# ///
+
+import regex as re
+
+import pandas as pd
+
+from datasets import load_dataset, concatenate_datasets
+from huggingface_hub import HfFileSystem
+
+
+from u_func import *
+
+#consider appendix
+appendix = False
+#which
+a="_4"
+#set years
+start_year = 1930
+#last year to process
+stop_year = 1930
+year_list = sorted(make_year_list(start_year,stop_year))
+if appendix:
+        year_list = [i+a for i in year_list]
+
+def get_files_year(year:str)->list[str]:
+    #get filenames in a year
+    fs = HfFileSystem()
+    # List files
+    try:
+        f_dict = fs.ls(f"datasets/chcaa/kb-books/data/{year}")
+        f_names = [i.get("name") for i in f_dict]
+        f_names = [re.sub("datasets/chcaa/kb-books/","",i) for i in f_names]
+    except FileNotFoundError:
+        f_names = "Not Found"
+    return f_names
+
+
+def main():
+    #load in wordset to check against
+    danish_words=list(pd.read_csv("./ods_fullforms_2020-08-26.csv", sep  = "\t")["A"])
+    danish_words = [i.lower() for i in danish_words]
+    danish_words = list(set(danish_words))
+    
+    
+
+    for year in year_list:
+        print(f"STARTING YEAR {year}...")
+        #load in data
+        #year_path = os.path.join("..","data",year)
+        #year_data = load_from_disk(year_path)
+        year_files = get_files_year(year)
+
+        if year_files == "Not Found":
+            print(f"{year} does not exist")
+            continue
+
+        year_data = load_dataset("chcaa/kb-books", split="train",
+                    data_files=year_files)
+       
+        #count tokens
+        #drop image
+        year_data = year_data.remove_columns("page_image")
+
+        #shuffling and sharding is to try and increase efficiency of the processes
+        #if a single process gets stuck with an unlucky draw of pages the available cpu
+        #power is not fully utilized
+
+        #shuffle dataset
+        year_data = year_data.shuffle(seed=1956)
+        #flatten indices
+        year_data = year_data.flatten_indices()
+        #shard the year
+        year_data = shard_ds(year_data)
+        #print(year_data)
+        yd_list = []
+        for i in year_data:
+            i = i.map(
+                                  count_tokens_and_words,
+                                  fn_kwargs = {"colname":"page_text",
+                                               "wordlist":danish_words},
+                                  num_proc = 16)
+            yd_list.append(i)
+        #print(yd_list)
+        #reassemble
+        year_data = concatenate_datasets(yd_list)
+
+        cols = year_data.column_names
+        wanted_cols = ["page_id","title","published",
+                       "page_text_n_tokens",
+                       "page_text_rel_a_words",
+                       "page_text_rel_words",
+                       "page_text_punkt_tokens",
+                       "page_text_a_tokens",
+                       "file_name"]
+        unwanted_cols = [i for i in cols if i not in wanted_cols]
+        #remove unnecessary columns
+        year_data = year_data.remove_columns(column_names=unwanted_cols)  
+        #save by year
+        year_data.to_parquet(f"./metadata/{year}.parquet")
+
+
+if __name__ == "__main__":
+    main()

ocr_metadata/token_count/meta_data.json

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

ocr_metadata/token_count/ods_fullforms_2020-08-26.csv

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

ocr_metadata/token_count/reorganize_metadata.py

@@ -0,0 +1,24 @@
+# /// script
+# requires-python = "==3.12"
+# dependencies = [
+#     "datasets>=3.5.0"
+# ]
+# ///
+import os
+from datasets import Dataset, concatenate_datasets
+
+
+def main():
+    #load files
+    ds_list = []
+    files = os.listdir("./metadata")
+    for i in sorted(files):
+        fp = f"./metadata/{i}"
+        ds = Dataset.from_parquet(fp)
+        ds_list.append(ds)
+    ds_big = concatenate_datasets(ds_list)
+    #save as one file
+    ds_big.to_json(f"meta_data.json")
+
+if __name__ == "__main__":
+    main()