Add scripts to tag data and improve cleaning

BabyLM.py

@@ -36,6 +36,16 @@ class BabyLM(datasets.GeneratorBasedBuilder):
             description="Full version of the dataset with 100M words",
             version="1.0.0",
         )
+        datasets.BuilderConfig(
+            name="strict_small_gold",
+            description="Small version of the dataset with 10M words and gold POS tags",
+            version="1.0.0",
+        ),
+        datasets.BuilderConfig(
+            name="strict_gold",
+            description="Full version of the dataset with 100M words and gold POS tags",
+            version="1.0.0",
+        )
     ]
 
     DEFAULT_CONFIG_NAME = "strict_small"
@@ -44,6 +54,7 @@ class BabyLM(datasets.GeneratorBasedBuilder):
             features = datasets.Features(
                 {
                     "text": datasets.Value("string"),
+                    "tagged_text": datasets.Value("string"),
                     "filename": datasets.Value("string"),
                 }
             )
@@ -59,16 +70,20 @@ class BabyLM(datasets.GeneratorBasedBuilder):
         """ 
         Returns data for different splits 
         """
-    
+
         if self.config.name == "strict_small":
             train_data_dir = "10M"
         else: 
             train_data_dir = "100M"
+        if 'gold' in self.config.name:
+            folder = 'tagged_gold'
+        else:
+            folder = 'tagged'
 
         urls_to_download = {
-            "train": [f"clean/{train_data_dir}/{fn}" for fn in filenames],
-            "dev": [f"clean/dev/{fn}" for fn in filenames],
-            "test": [f"clean/test/{fn}" for fn in filenames]
+            "train": [f"{folder}/{train_data_dir}/{fn}" for fn in filenames],
+            "dev": [f"{folder}/dev/{fn}" for fn in filenames],
+            "test": [f"{folder}/test/{fn}" for fn in filenames]
         } 
 
         downloaded_files = dl_manager.download_and_extract(urls_to_download)
@@ -108,6 +123,14 @@ class BabyLM(datasets.GeneratorBasedBuilder):
         for filepath in filepaths:
             with open(filepath, encoding="utf-8") as f:
                 filename = filepath.split("/")[-1]
+                is_tags = False
+                text = ""
+                # Every other row contains POS tags
                 for row in f:
-                    yield global_idx, {"text": row, "filename": filename}
-                    global_idx += 1 
+                    if is_tags:
+                        yield global_idx, {"text": text, "tagged_text": row, "filename": filename}
+                        global_idx += 1 
+                        is_tags = False
+                    else:
+                        text = row
+                        is_tags = True

clean_data.py

@@ -5,17 +5,24 @@ import re
 from nltk import tokenize
 
 def clean_aochildes(lines):
-    """ For aochildes, we just remove the space between the punctuation mark and the final word """
+    """ For aochildes, we remove the space between the punctuation mark and the final word and join together every 5 lines """
     new_lines = []
-    for line in lines:
-        new_lines.append(line[:-3] + line[-2:])
+    joined = []
+    for i, line in enumerate(lines):
+        new_line = line[:-3] + line[-2:]
+        joined.append(new_line.strip())
+        if i % 5 == 0:
+            new_lines.append(" ".join(joined) + "\n")
+            joined = []
     return new_lines
 
 def clean_bnc_spoken(lines):
     """ For bnc_spoken, we lowercase """
     new_lines = []
     for line in lines:
-        new_lines.append(line.lower())
+        new_line = line.lower()
+        if new_line != '\n':
+            new_lines.append(new_line)
     return new_lines
 
 def clean_cbt(lines):
@@ -38,15 +45,16 @@ def clean_cbt(lines):
     return new_lines
 
 def clean_children_stories(lines):
-    """ For children_stories, we lowercase and split long lines into sentences """
+    """ For children_stories, we lowercase """
     new_lines = []
     for line in lines:
-        sentences = [s + '\n' for s in tokenize.sent_tokenize(line.lower().strip()) if s != '']
-        new_lines.extend(sentences)
+        new_line = line.lower().strip()
+        if new_line != '':
+            new_lines.append(new_line + "\n")
     return new_lines
 
 def clean_gutenberg(lines):
-    """ For gutenberg, we lowercase, remove italics, group lines into paragraphs and then split into sentences. We also remove any lines containing '*' or 'p.' """
+    """ For gutenberg, we lowercase, remove italics and group lines into paragraphs. We also remove any lines containing '*' or 'p.' """
     # Get paragraphs
     paragraphs = []
     paragraph = ""
@@ -54,31 +62,27 @@ def clean_gutenberg(lines):
         # Remove italics
         tmp_line = line.lower().strip().replace('_','')
         if tmp_line == "" and paragraph != "":
-            paragraphs.append(paragraph[:-1] + '\n')
+            if len(paragraph.split()) > 2 and not paragraph.split()[-1][-1].isnumeric(): # Remove paragraphs with less than 3 words and those that end in a number (probably part of a bibliography)
+                paragraphs.append(paragraph[:-1] + '\n')
             paragraph = ""
         else:
             paragraph += tmp_line + " "
     
     # Bad characters - gutenberg has a lot of figures, footnotes, chapter names etc that we want to remove
     bad_chars = ['*', 'p.', '=', '|', '[', ']', '       ', '    ', 'v.']
-
-    # Split into sentences using NLTK
-    new_lines = []
-    for paragraph in paragraphs:
-        sentences = [s + '\n' for s in tokenize.sent_tokenize(paragraph) if s != '' and s[0] != '(']
-        sentences = [s for s in sentences if not any([c in s for c in bad_chars])]
-        if len(sentences) > 0:
-           new_lines.extend(sentences)
+    new_lines = [p.strip()+'\n' for p in paragraphs if not any([c in p for c in bad_chars]) and p != '' and p != '\n' and p[0] != '(']
     return new_lines
 
 def clean_open_subtitles(lines):
-    """ For open_subtitles, we lowercase, remove subtitle dashes and fix the lowercase 'l' problem """
+    """ For open_subtitles, we lowercase, remove subtitle dashes and fix the lowercase 'l' problem. We also join every 5 lines. """
     punctuation = ['.', ',', '?', '!', ':', ';', '(', ')', '[', ']', '{', '}', '"', "'", '“', '”', '—', '–', ' ', '\n']
     new_lines = []
+    joined = []
+    count = 0
     for line in lines:
         new_line = line.lower()
         # Skip music lines
-        if '♪' in new_line or '[' in new_line or ']' in new_line:
+        if '♪' in new_line or '[' in new_line or ']' in new_line or '‎' in new_line:
             continue
         if new_line[0:2] in ["- ", "– ", "— "]:
             new_line = new_line[2:]
@@ -100,14 +104,21 @@ def clean_open_subtitles(lines):
         new_line = new_line.replace(' lt', ' it')
         new_line = new_line.replace(' lt', ' it')
         new_line = new_line.replace(' lv', ' iv')
-        new_lines.append(new_line.strip() + '\n')
+        if new_line.strip() != '':
+            joined.append(new_line.strip())
+            count += 1
+            if count % 5 == 0:
+                new_lines.append(" ".join(joined) + '\n')
+                joined = []
     return new_lines
 
 def clean_qed(lines):
     """ For qed, we lowercase and normalise punctuation, remove words contained in parentheses,
-    remove lines that arejust character's names and fix the lowercase 'l' problem"""
+    remove lines that are just character's names and fix the lowercase 'l' problem. We also join every 5 lines. """
 
     new_lines = []
+    count = 0
+    joined = []
     for line in lines:
         # Before lowercasing, check if the words in the line are uppercase containing lowercase 'l' instead of 'I' and fix accordingly
         words = line.split()
@@ -150,11 +161,15 @@ def clean_qed(lines):
 
         new_line = new_line.strip()
         if new_line != "":
-            new_lines.append(new_line + '\n')
+            joined.append(new_line)
+            count += 1
+            if count % 5 == 0:
+                new_lines.append(" ".join(joined) + '\n')
+                joined = []
     return new_lines
 
 def clean_simple_wikipedia(lines):
-    """ For simple_wikipedia, we lowercase, remove empty lines and article names and split paragraphs into sentences."""
+    """ For simple_wikipedia, we lowercase, remove empty lines and article names."""
     new_lines = []
     next_line_is_article_name = False
     for line in lines:
@@ -164,20 +179,26 @@ def clean_simple_wikipedia(lines):
         if line.strip() == "":
             next_line_is_article_name = True
             continue
-        sentences = [s + '\n' for s in tokenize.sent_tokenize(line.lower()) if s != '']
-        new_lines.extend(sentences)
+        if len(line.split()) > 2:
+            new_lines.append(line.lower())
     return new_lines
 
 def clean_switchboard(lines):
-    """ For switchboard, we lowercase """
+    """ For switchboard, we lowercase and join every 5 lines. """
     new_lines = []
+    count = 0
+    joined = []
     for line in lines:
-        new_line = line.lower()
-        new_lines.append(new_line)
+        new_line = line.lower().strip()
+        joined.append(new_line)
+        count += 1
+        if count % 10 == 0:
+            new_lines.append(" ".join(joined) + '\n')
+            joined = []
     return new_lines
 
 def clean_wikipedia(lines):
-    """ For wikipedia, we lowercase, remove empty lines and article names and split paragraphs into sentences.
+    """ For wikipedia, we lowercase and remove empty lines and article names.
      We also remove lines that seem to be figure names or table entries. """
     new_lines = []
     for line in lines:
@@ -201,9 +222,7 @@ def clean_wikipedia(lines):
         if all_numeric or all_uppercase:
             continue
     
-        # Split into sentences using NLTK
-        sentences = [s + '\n' for s in tokenize.sent_tokenize(new_line.lower()) if s != '']
-        new_lines.extend(sentences)
+        new_lines.append(new_line.lower().strip() + '\n')
     return new_lines
 
 CLEAN_FUNCTIONS = {'aochildes' : clean_aochildes, 'bnc_spoken' : clean_bnc_spoken, 'cbt' : clean_cbt, 'children_stories' : clean_children_stories, 'gutenberg' : clean_gutenberg, 'open_subtitles' : clean_open_subtitles, 'qed' : clean_qed, 'simple_wikipedia' : clean_simple_wikipedia, 'switchboard' : clean_switchboard, 'wikipedia' : clean_wikipedia}
@@ -230,6 +249,8 @@ if __name__ == "__main__":
         # Clean the data
         if CLEAN_FUNCTIONS[corpus_name] is not None:
             lines = CLEAN_FUNCTIONS[corpus_name](lines)
+            # Replace multiple spaces with single space
+            lines = [re.sub(' +', ' ', line) for line in lines if line.strip() != '']
 
         # Write the new file
         new_file = file.replace('original', 'clean')

tag_data.py

@@ -0,0 +1,149 @@
+""" Script used to tag the data with POS tags. """
+
+import os
+import re
+from transformers import AutoTokenizer
+
+import nltk, sys
+
+UNSUPERVISED_POS_TAG_MAP = {
+   "and" : 'CONJ',
+   "|" : 'NOUN',
+   "states" : 'NOUN',
+   "school" : 'NOUN',
+   ".\"" : '.',
+   "-" : '.',
+   "five" : 'NUM',
+   "1" : 'NUM',
+   "they" : 'PRON',
+   "of" : 'ADP',
+   "are" : 'VERB',
+   "(" : '.',
+   "american" : 'ADJ',
+   "'s" : 'VERB',
+   "\"" : 'NOUN',
+   "the" : 'DET',
+   "a" : 'DET',
+   "after" : 'ADP',
+   "th" : 'NOUN',
+   "good" : 'ADJ',
+   "her" : 'PRON',
+   "night" : 'NOUN',
+   "to" : 'PRT',
+   "used" : 'VERB',
+   "," : '.',
+   "sir" : 'NOUN',
+   "tell" : 'VERB',
+   "lot" : 'NOUN',
+   "amp" : 'NOUN',
+   "doing" : 'VERB'
+}
+
+def tag_with_nltk(text, en_ptb_map):
+    """ Given a list of text, tag each word with its POS tag using NLTK """
+    new_lines = []
+    for line in text:
+        tokens = line.split()
+        tagged = nltk.pos_tag(tokens)
+        # Map the NLTK PTB tags to the universal tags
+        tagged = [(token, en_ptb_map[tag]) for (token, tag) in tagged]
+        new_lines.append(tagged)
+    return new_lines
+
+def write_to_file(tagged, output_file):
+    """ Given a list of tagged lines, write them to the given output file """
+    with open(output_file, 'w') as f:
+        for line in tagged:
+            for token, tag in line:
+                f.write(f'{token}__<label>__{tag} ')
+            f.write('\n')
+
+def tokenize_lines(text, tokenizer):
+    new_lines = []
+    for line in text:
+        tokens = tokenizer.backend_tokenizer.pre_tokenizer.pre_tokenize_str(line)
+        tokens = [t[0].replace("Ġ", "").replace('Ċ','\n') for t in tokens]
+        new_lines.append(' '.join(tokens))
+    return new_lines
+
+def get_tags_from_file(file):
+    with open(file, 'r') as f:
+        lines = f.read().splitlines()
+
+    gold_tagged_lines = []
+    pred_tagged_lines = []
+    gold_tagged = []
+    pred_tagged = []
+    total = 0
+    correct = 0
+    for line in lines:
+        if line == '':
+            gold_tagged_lines.append(gold_tagged)
+            pred_tagged_lines.append(pred_tagged)
+            gold_tagged = []
+            pred_tagged = []
+        else:
+            token, gold_tag, _, pred_tag = line.strip().split(' ')
+            gold_tagged.append((token, gold_tag))
+            # Use the manual map to map the predicted tags to the universal tags
+            pred_tagged.append((token, UNSUPERVISED_POS_TAG_MAP[pred_tag]))
+            total += 1
+            if gold_tag == UNSUPERVISED_POS_TAG_MAP[pred_tag]:
+                correct += 1
+    print(f'    Unsupervised Tagging Accuracy: {correct/total}')
+
+    return gold_tagged_lines, pred_tagged_lines
+
+def write_tagged_lines(filename, text, tagged_lines):
+    with open(filename, 'w') as f:
+        for line, tagged in zip(text, tagged_lines):
+            f.write(line)
+            f.write(' '.join([f'{token}__<label>__{tag}' for token, tag in tagged]) + '\n')
+
+tokenizer = AutoTokenizer.from_pretrained("CamBabyTrainers/BabyBERTa-3-8192-tokenizer")
+
+FOLDERS = ['10M', '100M', 'dev', 'test']
+
+if __name__ == "__main__":
+
+    # Read all text files from directory "BabyLM"
+    all_files = []
+    for folder in FOLDERS:
+        for root, dirs, files in os.walk(f"clean/{folder}"):
+            for file in files:
+                if file.endswith(".txt"):
+                    all_files.append(os.path.join(root, file))
+
+    # Get map from PTB tags to universal tags
+    en_ptb_map = {}
+    with open('../pos_tagging/en-ptb.map', 'r') as f:
+        for line in f.readlines():
+            (key, val) = line.split()
+            en_ptb_map[key] = val
+
+    for file in all_files:
+        print(file)
+        with open(file, 'r') as f:
+            lines = f.readlines()
+
+        # 1. Tokenize the lines in the text, tag with universal tags and write to tmp file
+        tokenized = tokenize_lines(lines, tokenizer)
+        tagged = tag_with_nltk(tokenized, en_ptb_map)
+        write_to_file(tagged, 'tmp.txt')
+
+        # 2. Run the unsupervised tagger on the tmp file
+        os.system(f'./../anchor/hmm --output ../pos_tagging/10M_train_30_extended --data tmp.txt --pred tmp_tagged.txt')
+
+        # 3. Get the gold tags and predicted tags
+        gold_tagged_lines, pred_tagged_lines = get_tags_from_file('tmp_tagged.txt')
+        
+        assert len(gold_tagged_lines) == len(pred_tagged_lines) == len(lines)
+
+        # 4. Write the tagged lines to the original file
+        new_file = file.replace('clean', 'tagged')
+        os.makedirs(os.path.dirname(new_file), exist_ok=True)
+        write_tagged_lines(new_file, lines, pred_tagged_lines)
+
+        new_file = file.replace('clean', 'tagged_gold')
+        os.makedirs(os.path.dirname(new_file), exist_ok=True)
+        write_tagged_lines(new_file, lines, gold_tagged_lines)