Update README.md

README.md

@@ -17,3 +17,125 @@ configs:
   - split: train
     path: data/train-*
 ---
+
+```python
+
+import os
+
+import datasets
+import torch
+from transformers import ModernBertForSequenceClassification, pipeline
+
+_GPU_ID = os.getenv("CUDA_VISIBLE_DEVICES", "0")
+
+
+def load_model(gpu_index=0):
+    model = ModernBertForSequenceClassification.from_pretrained(
+        "flozi00/GermanEduScorer-ModernBERT-base",
+        reference_compile=False,
+        attn_implementation="sdpa",
+    ).to(torch.bfloat16)
+
+    model = torch.compile(model, dynamic=True, mode="max-autotune")
+
+    pipe = pipeline(
+        "text-classification",
+        model=model,
+        tokenizer="flozi00/GermanEduScorer-ModernBERT-base",
+        device=gpu_index,
+        torch_dtype=torch.bfloat16,
+    )
+
+    return pipe
+
+pipe0 = load_model(0)
+tokenizer_kwargs = {"truncation": True}
+
+BAD_WORDS = [
+    "Sofort lieferbar",
+]
+
+
+def process_chunk(pipe, texts):
+    if not texts:
+        return []
+    return [
+        int(x["label"])
+        for x in pipe(
+            texts,
+            batch_size=256,
+            truncation=True,
+            max_length=1024,
+        )
+    ]
+
+def classification_wrapper(text_list: list):
+    return process_chunk(pipe0, text_list)
+
+def map_edu(example):
+    example["content"] = example["text"]
+    example["label"] = classification_wrapper(example["text"])
+    return example
+
+for SET_ID in ["0", "1", "2", "3"]:
+    base_url = "https://huggingface.co/datasets/HuggingFaceFW/fineweb-2/resolve/main/data/deu_Latn/train/"
+    data_files = {
+        "train": [base_url + f"00{SET_ID}_0000{i}.parquet" for i in range(10)]
+        + [base_url + f"00{SET_ID}_000{i}.parquet" for i in range(10, 38)]
+    }
+
+    fineweb = datasets.load_dataset(
+        "parquet",
+        data_files=data_files,
+        split="train",
+        num_proc=4,
+        cache_dir=f"./cache_fineweb_{SET_ID}",
+    )
+
+    chunk_size = 100_000
+    part_size = len(fineweb) // 4
+    total_samples = part_size * (int(_GPU_ID) + 1)
+    output_path = f"fineweb2_edu_4up_german_split_{int(SET_ID)+1}-of-4"
+
+    for i in range(part_size * int(_GPU_ID), total_samples, chunk_size):
+        end_idx = min(i + chunk_size, total_samples)
+        checkpoint_path = f"chunks/{output_path}_chunk_{i}"
+
+        # Try to load existing chunk
+        try:
+            dset = datasets.load_from_disk(checkpoint_path)
+            print(f"Chunk {i} to {end_idx} already processed, skipping...")
+            continue
+        except Exception:
+            print(f"Processing chunk {i} to {end_idx} of {total_samples}")
+
+            chunk = fineweb.select(range(i, end_idx))
+            processed_chunk = chunk.map(
+                map_edu,
+                remove_columns=chunk.column_names,
+                batch_size=1024,
+                batched=True,
+            ).filter(lambda x: x["label"] >= 4, num_proc=8)
+            processed_chunk = processed_chunk.rename_column("content", "text")
+
+            processed_chunk.save_to_disk(checkpoint_path)
+            print(f"Saved checkpoint to {checkpoint_path}")
+
+        if i % 1_000_000 == 0 and _GPU_ID == "0" and i > 0:
+            sets_to_push = []
+            # list all folders in the chunks directory
+            for folder in os.listdir("chunks"):
+                # load the dataset
+                sets_to_push.append(datasets.load_from_disk(f"chunks/{folder}"))
+            state_ds = datasets.concatenate_datasets(sets_to_push)
+            for bad_word in BAD_WORDS:
+                state_ds = state_ds.filter(
+                    lambda x: bad_word not in x["text"], num_proc=8
+                )
+            state_ds = state_ds.filter(
+                lambda x: len(x["text"]) > 1024 and len(x["text"]) <= 100_000,
+                num_proc=8,
+            )
+            state_ds.push_to_hub("Fineweb2-German-Eduscore-4andMore")
+
+```