Add files using upload-large-folder tool

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

NOTICE

@@ -0,0 +1,48 @@
+tokenizer-lm
+Copyright 2026 Clara Meister
+
+This product includes software developed as part of the tokenizer-lm study,
+licensed under the Apache License, Version 2.0. See LICENSE.
+
+--------------------------------------------------------------------------------
+Third-party components
+--------------------------------------------------------------------------------
+
+nanochat
+https://github.com/karpathy/nanochat
+MIT License, Copyright (c) 2025 Andrej Karpathy
+
+The model architecture, optimizer and dataloader come from nanochat. This project
+uses a patched copy (https://github.com/cimeister/nanochat, branch
+tokenizer-lm-patches) that adds a configurable value-embedding dimension, a
+configurable logit soft cap, and a configurable learning-rate width exponent for
+muP. The released model class scripts/hf_release/nanochat_model.py reimplements that
+architecture for the HuggingFace transformers interface. The full MIT license text
+is at nanochat/LICENSE.
+
+--------------------------------------------------------------------------------
+Training data
+--------------------------------------------------------------------------------
+
+The released model weights were trained on a mixture of:
+
+  FineWeb-Edu           HuggingFaceFW/fineweb-edu             ODC-By
+  FineWeb-2 (filtered)  HuggingFaceFW/fineweb-2               ODC-By
+  FineMath 4plus        HuggingFaceTB/finemath                ODC-By
+  StarCoderData         bigcode/starcoderdata                 listed as "other"
+
+Licenses as stated on each dataset's Hugging Face card, read 2026-08-17. The
+multilingual and code portions were used through quality-filtered derivatives
+prepared inside the Swiss AI initiative; see EXPERIMENTAL_SETUP.md for the exact
+paths and filters.
+
+--------------------------------------------------------------------------------
+Tokenizers not redistributed
+--------------------------------------------------------------------------------
+
+Two off-the-shelf tokenizers were used as reference points and are cited rather than
+redistributed: the Apertus tokenizer (swiss-ai/Apertus-70B-2509, the same artifact as
+Mistral-Nemo's tokenizer) and the Llama-3 tokenizer (recorded at training time as
+NousResearch/Meta-Llama-3-8B). In the names of the tokenizers this project trained,
+"gpt4o", "claude" and "gpt2" refer to a borrowed pretokenization regular expression,
+not to those vendors' tokenizers.

README.md

@@ -0,0 +1,95 @@
+---
+license: odc-by
+language:
+- multilingual
+task_categories:
+- text-generation
+tags:
+- tokenizer
+- pretraining-corpus
+---
+
+# tokenizer-lm training corpora
+
+The two corpora behind [`cmeister/tokenizer-lm-ablations`](https://huggingface.co/cmeister/tokenizer-lm-ablations): the
+mixture every released language model trained on, and the pool the tokenizers were trained
+from. Both are samples of public corpora, released so the models' results can be
+reproduced rather than taken on faith.
+
+Staged 2026-10-19.
+
+## `lm_training_mixture/`
+
+100 parquet shards, **5,000,000 documents**, 24.97 GB
+of text, 13.71 GB on disk. Sampled with seed 42;
+`metadata.json` records every source path, weight, document count and byte count, and
+`lm_dataset_sampler.py` is the script that produced it.
+
+Composition by sampling weight: FineWeb-Edu 36.8%, FineWeb-2 31.6% across
+30 languages, FineMath 15.8%, StarCoder python and javascript 15.8%.
+
+### Read this before using it
+
+**The shards have one column, `text`.** No document id, no URL, no source dataset, no
+repository name. Every provenance field was dropped when the mixture was sampled, and the
+sampling was not recorded per document.
+
+The practical consequences are worth stating rather than leaving to be discovered:
+
+- The 15.8% of the mixture that came from StarCoder cannot be identified after the
+  fact, so it cannot be separated from the prose, attributed to the repositories it came
+  from, or removed on request. If you maintain a repository that was in The Stack and you
+  have opted out, we cannot honour that opt-out inside this file, because the information
+  needed to act on it no longer exists. We can remove the corpus as a whole; please open a
+  discussion on this repository.
+- Per-language analysis of the multilingual portion is not possible from the file alone.
+- Deduplication against another corpus has to be done on text, not on identifiers.
+
+The tokenizer pool below does not have this problem, and is the better starting point for
+anything that depends on knowing where a document came from.
+
+## `tokenizer_training_pool/`
+
+1,921 parquet files over 6 sources, 3.21 GB.
+This is the pool the tokenizer-training compositions draw from; a given tokenizer uses a
+weighted subset of it, with the weights recorded in `scripts/train_custom_tokenizers.py` in
+the study's code repository. `sampling_stats.json` records the per-source targets and
+sampling temperatures, and `tokenizer_dataset_sampler.py` is the script that produced it.
+
+| Source | Files | GB | Columns |
+|---|---|---|---|
+| `finemath` | 1 | 0.05 | `id`, `metadata`, `text` |
+| `fineweb` | 50 | 1.41 | `id`, `metadata`, `text` |
+| `fineweb2` | 1,781 | 1.36 | `id`, `metadata`, `text` |
+| `infimath` | 1 | 0.05 | `id`, `metadata`, `text` |
+| `megamath` | 1 | 0.11 | `id`, `metadata`, `text` |
+| `starcoder` | 87 | 0.22 | `clarity`, `content`, `difficulty`, `educational`, `id`, `max_stars_count`, `max_stars_repo_name`, `max_stars_repo_path`, `output`, `practice`, `quality`, `quantile` |
+
+Provenance is intact here. StarCoder rows carry `max_stars_repo_name` and
+`max_stars_repo_path`, so code can be attributed to its repository and removed on request.
+Web and math rows carry an `id` and a `metadata` struct holding the Common Crawl path and
+the source domain.
+
+## Where this came from, and what that means for licensing
+
+The underlying public datasets are
+[FineWeb-Edu](https://huggingface.co/datasets/HuggingFaceFW/fineweb-edu) (ODC-By),
+[FineWeb-2](https://huggingface.co/datasets/HuggingFaceFW/fineweb-2) (ODC-By),
+[FineMath](https://huggingface.co/datasets/HuggingFaceTB/finemath) (ODC-By) and
+[StarCoderData](https://huggingface.co/datasets/bigcode/starcoderdata), whose card lists
+its license as "other" and which carries The Stack's opt-out undertaking. Licenses as
+stated on each dataset's card, read 2026-08-17.
+
+What is published here is not sampled from those public versions directly. It was sampled
+from quality-filtered derivatives prepared inside the Swiss AI initiative, so this release
+also redistributes that filtering work. Attribution for the filtering belongs to that
+project.
+
+If you are an author or maintainer with a removal request, open a discussion here. For the
+tokenizer pool we can act on it precisely; for the language-model mixture, see the
+limitation stated above.
+
+## Citation
+
+See the model repository [`cmeister/tokenizer-lm-ablations`](https://huggingface.co/cmeister/tokenizer-lm-ablations) for the
+study these corpora belong to.

lm_training_mixture/lm_dataset_sampler.py

@@ -0,0 +1,1093 @@
+#!/usr/bin/env python3
+"""
+corpus_sampler.py
+
+Takes an existing corpus directory containing parquet files and creates a
+sampled version of it.  Two modes are supported:
+
+MULTILINGUAL mode (default)
+    input_dir/
+        <lang_code>/
+            *.parquet
+        <lang_code>/
+            ...
+    output_dir/
+        <lang_code>/
+            data.parquet
+        ...
+
+    Language proportions are computed from **UTF-8 text byte sizes** (measured
+    from the text column) using a temperature formula:
+        scaled_size = size ^ (1 / temperature)
+    T=1.0  → strictly proportional to input sizes
+    T>1.0  → upsamples smaller languages (flattens the distribution)
+    A 50% cap is applied per language after temperature scaling.
+    A minimum row floor per language is enforced.
+
+    Because reading the full text column of a multi-TB corpus would be
+    prohibitively slow, text byte sizes are *estimated* by sampling a
+    configurable number of rows per language (--text_sample_rows, default 2000)
+    and extrapolating.
+
+MONOLINGUAL mode  (--monolingual)
+    input_dir/
+        *.parquet
+        ...
+    output_dir/
+        data.parquet
+
+    All parquet files in input_dir are treated as a single pool.
+    The target row count is derived directly from --total_size_gb.
+    Temperature and the per-language cap are not applicable.
+    --min_rows_floor still acts as a lower bound.
+
+In both modes the total target is specified in GB of **raw text bytes**
+(uncompressed UTF-8), not on-disk parquet bytes.
+"""
+
+import os
+import json
+import math
+import random
+import logging
+import argparse
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.compute as pc
+import pyarrow.parquet as pq
+from tqdm import tqdm
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Defaults
+# ---------------------------------------------------------------------------
+
+DEFAULT_TEMP = 5.0       # same default as XLM_R_TEMP in corpus_downloader.py
+DEFAULT_CAP = 0.5        # 50 % cap per language
+DEFAULT_MIN_ROWS = 1000  # minimum row floor per language
+DEFAULT_SEED = 42
+DEFAULT_TEXT_COLUMN = "text"
+DEFAULT_TEXT_SAMPLE_ROWS = 2000
+
+# ---------------------------------------------------------------------------
+# Proportion helpers  (mirror of _calculate_proportions in corpus_downloader.py)
+# ---------------------------------------------------------------------------
+
+def _calculate_proportions(
+    original_sizes: Dict[str, float],
+    temperature: float,
+    cap: float = DEFAULT_CAP,
+) -> Dict[str, float]:
+    """
+    Compute per-language sampling proportions with temperature scaling and
+    a per-language cap.
+
+    Formula (same as corpus_downloader.py):
+        powered_size[lg] = size[lg] ^ (1 / temperature)
+        proportion[lg]   = powered_size[lg] / sum(powered_sizes)
+
+    After computing raw proportions any language exceeding `cap` is clamped;
+    the remaining budget is re-distributed among uncapped languages and the
+    result is re-normalised to 1.
+    """
+    if not original_sizes:
+        return {}
+
+    # --- 1. Temperature scaling ---
+    if temperature == 1.0:
+        powered = dict(original_sizes)
+    else:
+        log.info(f"Applying temperature {temperature} to size-based proportions.")
+        powered = {lg: size ** (1.0 / temperature) for lg, size in original_sizes.items()}
+
+    total_powered = sum(powered.values())
+    if total_powered == 0:
+        return {}
+
+    proportions: Dict[str, float] = {
+        lg: p / total_powered for lg, p in powered.items()
+    }
+
+    # --- 2. Cap ---
+    capping_needed = any(p > cap for p in proportions.values())
+    if capping_needed:
+        for lg, prop in proportions.items():
+            if prop > cap:
+                log.warning(
+                    f"[{lg}] proportion {prop*100:.1f}% exceeds cap. "
+                    f"Capping at {cap*100:.0f}%."
+                )
+                proportions[lg] = cap
+
+        capped_total = sum(p for p in proportions.values() if p == cap)
+        remaining = 1.0 - capped_total
+        uncapped_powered_total = sum(
+            powered[lg] for lg, p in proportions.items() if p < cap
+        )
+        if uncapped_powered_total > 0:
+            for lg in proportions:
+                if proportions[lg] < cap:
+                    proportions[lg] = (powered[lg] / uncapped_powered_total) * remaining
+        elif remaining > 0:
+            log.warning("All languages are at the cap. Distribution may not sum to 1.")
+
+    # --- 3. Re-normalise ---
+    total = sum(proportions.values())
+    if not math.isclose(total, 1.0, rel_tol=1e-5):
+        log.info(f"Proportions sum to {total:.6f}; re-normalising.")
+        proportions = {lg: p / total for lg, p in proportions.items()}
+
+    return proportions
+
+
+# ---------------------------------------------------------------------------
+# Filesystem helpers
+# ---------------------------------------------------------------------------
+
+def discover_languages(input_dir: Path, lang_subdir: str = "") -> Dict[str, List[Path]]:
+    """
+    Walk input_dir and return a mapping of language_code → list of parquet files.
+    Only immediate subdirectories that contain at least one .parquet file are
+    included.
+
+    If lang_subdir is set, parquet files are looked for inside
+    input_dir/<lang_code>/<lang_subdir>/ rather than directly inside
+    input_dir/<lang_code>/.
+    """
+    langs: Dict[str, List[Path]] = {}
+    for subdir in sorted(input_dir.iterdir()):
+        if not subdir.is_dir():
+            continue
+        search_dir = subdir / lang_subdir if lang_subdir else subdir
+        if not search_dir.is_dir():
+            log.debug(f"Skipping '{subdir.name}': subdirectory '{lang_subdir}' not found.")
+            continue
+        parquets = validate_parquet_files(sorted(search_dir.glob("*.parquet")))
+        if parquets:
+            langs[subdir.name] = parquets
+        else:
+            log.debug(f"Skipping '{subdir.name}': no valid parquet files found in '{search_dir}'.")
+    return langs
+
+
+def discover_monolingual(input_dir: Path) -> List[Path]:
+    """
+    Return all .parquet files directly inside input_dir (non-recursive).
+    Raises ValueError if none are found.
+    """
+    parquets = validate_parquet_files(sorted(input_dir.glob("*.parquet")))
+    if not parquets:
+        raise ValueError(f"No valid .parquet files found directly in '{input_dir}'.")
+    return parquets
+
+
+def validate_parquet_files(files: List[Path]) -> List[Path]:
+    """
+    Return only the files that can be opened as valid parquet files.
+    Corrupt or invalid files are logged as warnings and excluded.
+    """
+    valid = []
+    for f in files:
+        try:
+            pq.ParquetFile(f)
+            valid.append(f)
+        except Exception as e:
+            log.warning(f"Skipping corrupt/invalid parquet file '{f}': {e}")
+    return valid
+
+
+def total_parquet_bytes(files: List[Path]) -> int:
+    """Return the sum of on-disk sizes (bytes) for a list of parquet files."""
+    return sum(f.stat().st_size for f in files)
+
+
+def count_rows(files: List[Path]) -> int:
+    """Count total rows across a list of parquet files without loading data."""
+    total = 0
+    for f in files:
+        pf = pq.ParquetFile(f)
+        total += pf.metadata.num_rows
+    return total
+
+
+# ---------------------------------------------------------------------------
+# Text byte measurement
+# ---------------------------------------------------------------------------
+
+def _measure_text_bytes_in_table(table: pa.Table, text_column: str) -> int:
+    """Sum UTF-8 byte lengths of the text column in an Arrow table."""
+    col = table.column(text_column)
+    # Cast to binary to get raw UTF-8 byte lengths (not character counts)
+    byte_lengths = pc.binary_length(col.cast(pa.large_binary()))
+    return pc.sum(byte_lengths, skip_nulls=True).as_py() or 0
+
+
+def estimate_text_bytes(
+    files: List[Path],
+    text_column: str,
+    sample_rows: int = DEFAULT_TEXT_SAMPLE_ROWS,
+    seed: int = DEFAULT_SEED,
+) -> Tuple[float, float]:
+    """
+    Estimate total UTF-8 text bytes by sampling rows and extrapolating.
+
+    Returns (estimated_total_text_bytes, avg_text_bytes_per_row).
+    """
+    total_rows = count_rows(files)
+    if total_rows == 0:
+        return 0.0, 0.0
+
+    rng = random.Random(seed)
+    sampled_count = 0
+    sampled_text_bytes = 0
+
+    # Distribute sample budget across files proportionally
+    file_row_counts = []
+    for f in files:
+        pf = pq.ParquetFile(f)
+        file_row_counts.append((f, pf.metadata.num_rows))
+
+    remaining = min(sample_rows, total_rows)
+
+    for f, frows in file_row_counts:
+        if remaining <= 0:
+            break
+        # Proportional allocation of sample budget to this file
+        file_budget = max(1, int(remaining * frows / max(total_rows - sampled_count, 1)))
+        file_budget = min(file_budget, frows, remaining)
+
+        table = pq.read_table(f, columns=[text_column])
+        # Cast to large_string to avoid offset overflow on take/concat
+        col = table.column(text_column)
+        if pa.types.is_string(col.type):
+            table = table.set_column(
+                table.schema.get_field_index(text_column),
+                text_column,
+                col.cast(pa.large_string()),
+            )
+        if len(table) > file_budget:
+            indices = sorted(rng.sample(range(len(table)), file_budget))
+            table = table.take(indices)
+
+        sampled_text_bytes += _measure_text_bytes_in_table(table, text_column)
+        sampled_count += len(table)
+        remaining -= len(table)
+
+    if sampled_count == 0:
+        return 0.0, 0.0
+
+    avg_text_bytes_per_row = sampled_text_bytes / sampled_count
+    estimated_total = avg_text_bytes_per_row * total_rows
+    return estimated_total, avg_text_bytes_per_row
+
+
+# ---------------------------------------------------------------------------
+# Schema helpers
+# ---------------------------------------------------------------------------
+
+def _promote_type(types: List[pa.DataType]) -> pa.DataType:
+    """
+    Given a list of Arrow types for the same column across files, return
+    the promoted (widest) type that can losslessly represent all of them.
+
+    Falls back to the first type if promotion is not needed or not possible.
+    """
+    if not types:
+        raise ValueError("Empty type list")
+    
+    unique = list({str(t): t for t in types}.values())
+    if len(unique) == 1:
+        return unique[0]
+
+    # Let PyArrow try automatic unification via a dummy schema merge
+    try:
+        dummy_schemas = [pa.schema([pa.field("_", t)]) for t in unique]
+        unified = pa.unify_schemas(dummy_schemas, promote_options="permissive")
+        return unified.field("_").type
+    except pa.ArrowInvalid:
+        log.warning(
+            f"Could not auto-promote types {[str(t) for t in unique]}; "
+            f"using first encountered type: {types[0]}"
+        )
+        return types[0]
+
+
+def get_common_schema(files: List[Path]) -> pa.Schema:
+    """
+    Determine the common schema across all parquet files.
+    
+    - Intersects column names (only columns present in *every* file are kept).
+    - For struct columns, intersects subfield names.
+    - Promotes types across files (e.g. int32 + int64 → int64) so that every
+      file can be safely cast to the resulting schema.
+    - Excludes pandas ``__index_level_*`` columns.
+    """
+    if not files:
+        raise ValueError("No files provided")
+    
+    schemas = []
+    for f in files:
+        pf = pq.ParquetFile(f)
+        schemas.append(pf.schema_arrow)
+    
+    # Find common column names, excluding pandas index columns
+    common_names = set(schemas[0].names)
+    for schema in schemas[1:]:
+        common_names &= set(schema.names)
+    common_names = {n for n in common_names if not n.startswith("__index_level_")}
+    
+    if not common_names:
+        raise ValueError("No common columns found across all files")
+    
+    # Build common schema with type promotion and struct subfield intersection
+    common_fields = []
+    for name in sorted(common_names):
+        # Collect the field from every schema
+        fields_across_files = [s.field(name) for s in schemas]
+        
+        if all(pa.types.is_struct(f.type) for f in fields_across_files):
+            # --- struct column: intersect subfield names, promote subfield types ---
+            subfield_name_sets = []
+            for f in fields_across_files:
+                subfield_name_sets.append(
+                    {f.type.field(i).name for i in range(f.type.num_fields)}
+                )
+            common_subfield_names = subfield_name_sets[0]
+            for s in subfield_name_sets[1:]:
+                common_subfield_names &= s
+            
+            if not common_subfield_names:
+                log.warning(
+                    f"Struct column '{name}' has no common subfields across files; skipping."
+                )
+                continue
+            
+            # For each common subfield, promote its type
+            promoted_subfields = []
+            for sf_name in sorted(common_subfield_names):
+                sf_types = []
+                for f in fields_across_files:
+                    for i in range(f.type.num_fields):
+                        sf = f.type.field(i)
+                        if sf.name == sf_name:
+                            sf_types.append(sf.type)
+                            break
+                promoted_subfields.append(pa.field(sf_name, _promote_type(sf_types)))
+            
+            common_fields.append(pa.field(name, pa.struct(promoted_subfields)))
+        
+        elif any(pa.types.is_struct(f.type) for f in fields_across_files):
+            # Mixed struct / non-struct across files — skip to be safe
+            log.warning(
+                f"Column '{name}' is struct in some files but not others; skipping."
+            )
+            continue
+        
+        else:
+            # --- scalar column: promote type ---
+            col_types = [f.type for f in fields_across_files]
+            common_fields.append(pa.field(name, _promote_type(col_types)))
+    
+    if not common_fields:
+        raise ValueError("No common columns survived schema intersection")
+    
+    return pa.schema(common_fields)
+
+
+def project_to_schema(table: pa.Table, target_schema: pa.Schema) -> pa.Table:
+    """
+    Project *and cast* a table to the target schema.
+
+    - Selects only the columns present in ``target_schema``.
+    - For struct columns, selects only the subfields present in the target
+      struct type and rebuilds the struct.
+    - Casts every column to the exact type declared in ``target_schema`` so
+      that all output tables are schema-identical and safe to concatenate.
+    """
+    projected_arrays = []
+    projected_fields = []
+    
+    for field in target_schema:
+        if field.name not in table.schema.names:
+            continue
+            
+        col = table[field.name]
+        
+        # Handle struct fields: select common subfields, then cast
+        if pa.types.is_struct(field.type) and pa.types.is_struct(col.type):
+            target_subfield_names = [field.type.field(i).name 
+                                    for i in range(field.type.num_fields)]
+            
+            subfield_arrays = []
+            for subfield_name in target_subfield_names:
+                subfield_array = pc.struct_field(col, [subfield_name])
+                subfield_arrays.append(subfield_array)
+            
+            col = pc.make_struct(*subfield_arrays, field_names=target_subfield_names)
+        
+        # Cast to the exact target type (handles e.g. int32→int64 promotion)
+        if col.type != field.type:
+            col = col.cast(field.type)
+        
+        projected_arrays.append(col)
+        projected_fields.append(field)
+    
+    return pa.table(projected_arrays, schema=pa.schema(projected_fields))
+
+
+def cast_to_large_string(schema: pa.Schema) -> pa.Schema:
+    """Cast all string columns to large_string to avoid 2GB offset overflow."""
+    new_fields = []
+    for field in schema:
+        if pa.types.is_string(field.type):
+            new_fields.append(pa.field(field.name, pa.large_string()))
+        elif pa.types.is_struct(field.type):
+            # Also handle string fields inside structs
+            subfields = []
+            for i in range(field.type.num_fields):
+                sf = field.type.field(i)
+                if pa.types.is_string(sf.type):
+                    subfields.append(pa.field(sf.name, pa.large_string()))
+                else:
+                    subfields.append(sf)
+            new_fields.append(pa.field(field.name, pa.struct(subfields)))
+        else:
+            new_fields.append(field)
+    return pa.schema(new_fields)
+
+
+# ---------------------------------------------------------------------------
+# Core sampling logic
+# ---------------------------------------------------------------------------
+
+def sample_language(
+    lang: str,
+    parquet_files: List[Path],
+    target_rows: int,
+    output_path: Path,
+    seed: int,
+    common_schema: Optional[pa.Schema] = None,
+    keep_columns: Optional[List[str]] = None,
+) -> int:
+    """
+    Sample `target_rows` rows from the combined pool of `parquet_files` for
+    one language and write them to `output_path` as a single parquet file.
+
+    Returns the actual number of rows written.
+    """
+    total_rows = count_rows(parquet_files)
+    actual_target = min(target_rows, total_rows)
+
+    if actual_target <= 0:
+        log.warning(f"[{lang}] target_rows={target_rows}, total_rows={total_rows}. Nothing to write.")
+        return 0
+
+    # If no common schema provided, compute it from these files
+    if common_schema is None:
+        common_schema = get_common_schema(parquet_files)
+    
+    # Pre-compute the large_string schema once for reuse
+    large_schema = cast_to_large_string(common_schema)
+    
+    # Sampling ratio determines strategy
+    sampling_ratio = actual_target / total_rows
+    
+    if sampling_ratio > 0.5:
+        # High ratio: load all, then sample
+        tables = []
+        for f in parquet_files:
+            table = pq.read_table(f)
+            table = project_to_schema(table, common_schema)
+            table = table.cast(large_schema)
+            tables.append(table)
+        
+        full_table = pa.concat_tables(tables)
+        
+        rng = random.Random(seed)
+        indices = sorted(rng.sample(range(len(full_table)), actual_target))
+        table = full_table.take(indices)
+    else:
+        # Low ratio: per-file sampling
+        rng = random.Random(seed)
+        collected = []
+        remaining = actual_target
+        
+        file_order = list(parquet_files)
+        rng.shuffle(file_order)
+        
+        for f in file_order:
+            if remaining <= 0:
+                break
+            
+            file_rows = pq.ParquetFile(f).metadata.num_rows
+            file_target = min(remaining, max(1, int(file_rows * sampling_ratio * 1.2)))
+            
+            if file_target > 0:
+                table_chunk = pq.read_table(f)
+                table_chunk = project_to_schema(table_chunk, common_schema)
+                table_chunk = table_chunk.cast(large_schema)
+                
+                if len(table_chunk) > file_target:
+                    indices = sorted(rng.sample(range(len(table_chunk)), file_target))
+                    table_chunk = table_chunk.take(indices)
+                
+                collected.append(table_chunk)
+                remaining -= len(table_chunk)
+        
+        if collected:
+            table = pa.concat_tables(collected)
+            if len(table) > actual_target:
+                indices = sorted(rng.sample(range(len(table)), actual_target))
+                table = table.take(indices)
+        else:
+            log.warning(f"[{lang}] No rows collected")
+            return 0
+    
+    # Drop columns not in the keep list (if specified)
+    if keep_columns is not None:
+        keep_set = set(keep_columns)
+        drop = [name for name in table.schema.names if name not in keep_set]
+        if drop:
+            table = table.drop(drop)
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    pq.write_table(table, output_path, compression="snappy")
+
+    return len(table)
+
+
+# ---------------------------------------------------------------------------
+# Main sampler class
+# ---------------------------------------------------------------------------
+
+class CorpusSampler:
+    def __init__(self, args: argparse.Namespace):
+        self.args = args
+        self.input_dir = Path(args.input_dir)
+        self.output_dir = Path(args.output_dir)
+        self.total_target_bytes = int(args.total_size_gb * (1024 ** 3))
+
+    def run(self):
+        if self.args.monolingual:
+            self._run_monolingual()
+        else:
+            self._run_multilingual()
+
+    def _run_monolingual(self):
+        # ------------------------------------------------------------------ #
+        # 1. Discover parquet files
+        # ------------------------------------------------------------------ #
+        log.info(f"Monolingual mode. Scanning: {self.input_dir}")
+        try:
+            parquet_files = discover_monolingual(self.input_dir)
+        except ValueError as e:
+            log.error(str(e))
+            return
+
+        log.info(f"Found {len(parquet_files)} parquet file(s).")
+
+        # ------------------------------------------------------------------ #
+        # 2. Measure input (text bytes)
+        # ------------------------------------------------------------------ #
+        log.info("Estimating text byte sizes (sampling rows)…")
+        total_text_bytes, text_bpr = estimate_text_bytes(
+            parquet_files,
+            self.args.text_column,
+            sample_rows=self.args.text_sample_rows,
+            seed=self.args.seed,
+        )
+        total_rows = count_rows(parquet_files)
+
+        log.info(
+            f"Input: {total_rows:,} rows, ~{total_text_bytes / 1e9:.3f} GB text "
+            f"(~{text_bpr:.0f} text bytes/row)."
+        )
+
+        if self.total_target_bytes >= total_text_bytes:
+            log.warning(
+                f"Target ({self.args.total_size_gb} GB text) >= estimated input "
+                f"({total_text_bytes / 1e9:.3f} GB text). Using all available rows."
+            )
+
+        # ------------------------------------------------------------------ #
+        # 3. Compute target row count
+        # ------------------------------------------------------------------ #
+        estimated_rows = int(self.total_target_bytes / text_bpr) if text_bpr > 0 else total_rows
+        floored_rows = max(estimated_rows, self.args.min_rows_floor)
+        target_rows = min(floored_rows, total_rows)
+
+        if floored_rows > estimated_rows:
+            log.info(
+                f"Proportional allocation ({estimated_rows:,} rows) is below "
+                f"floor ({self.args.min_rows_floor:,}). Using floor → {target_rows:,} rows."
+            )
+        if target_rows < floored_rows:
+            log.warning(
+                f"Available rows ({total_rows:,}) < requested ({floored_rows:,}). "
+                "Using all available rows."
+            )
+
+        log.info(f"Target: {target_rows:,} / {total_rows:,} rows.")
+
+        # ------------------------------------------------------------------ #
+        # 4. Compute common schema across all input files
+        # ------------------------------------------------------------------ #
+        common_schema = get_common_schema(parquet_files)
+        log.info(
+            "Common schema across all files:\n"
+            + "\n".join(f"  {f.name}: {f.type}" for f in common_schema)
+        )
+
+        # ------------------------------------------------------------------ #
+        # 5. Sample and write
+        # ------------------------------------------------------------------ #
+        out_file = self.output_dir / "data.parquet"
+
+        if out_file.exists():
+            log.info(f"Output already exists at {out_file}. Skipping.")
+        else:
+            written = sample_language(
+                lang="monolingual",
+                parquet_files=parquet_files,
+                target_rows=target_rows,
+                output_path=out_file,
+                seed=self.args.seed,
+                common_schema=common_schema,
+                keep_columns=self.args.columns,
+            )
+            log.info(f"Wrote {written:,} rows → {out_file}")
+
+        # ------------------------------------------------------------------ #
+        # 6. Save manifest
+        # ------------------------------------------------------------------ #
+        total_parquet = total_parquet_bytes(parquet_files)
+        manifest_path = self.output_dir / "sampling_manifest.json"
+        with open(manifest_path, "w", encoding="utf-8") as f:
+            json.dump(
+                {
+                    "args": vars(self.args),
+                    "total_input_parquet_gb": total_parquet / 1e9,
+                    "total_input_text_gb": total_text_bytes / 1e9,
+                    "target_text_gb": self.args.total_size_gb,
+                    "rows_available": total_rows,
+                    "rows_written": target_rows,
+                    "schema": [
+                        {"name": f.name, "type": str(f.type)} for f in common_schema
+                    ],
+                    "output": str(out_file),
+                },
+                f,
+                indent=2,
+            )
+        log.info(f"Manifest saved to {manifest_path}")
+        log.info("--- Monolingual sampling finished ---")
+
+    def _run_multilingual(self):
+        # ------------------------------------------------------------------ #
+        # 1. Discover languages and their parquet files
+        # ------------------------------------------------------------------ #
+        log.info(f"Multilingual mode. Scanning input directory: {self.input_dir}")
+        lang_files = discover_languages(self.input_dir, self.args.lang_subdir)
+        if not lang_files:
+            log.error("No language subdirectories with parquet files found. Exiting.")
+            return
+
+        log.info(f"Found {len(lang_files)} language(s) with valid parquet files: {sorted(lang_files)}")
+
+        # ------------------------------------------------------------------ #
+        # 2. Measure sizes (UTF-8 text bytes) to drive proportions
+        # ------------------------------------------------------------------ #
+        log.info(
+            f"Estimating text byte sizes (sampling {self.args.text_sample_rows} "
+            f"rows per language from column '{self.args.text_column}')…"
+        )
+        lang_text_sizes: Dict[str, float] = {}
+        lang_text_bpr: Dict[str, float] = {}
+        lang_row_counts: Dict[str, int] = {}
+
+        for lang, files in tqdm(lang_files.items(), desc="Measuring text sizes"):
+            lang_row_counts[lang] = count_rows(files)
+            est_total, est_bpr = estimate_text_bytes(
+                files,
+                self.args.text_column,
+                sample_rows=self.args.text_sample_rows,
+                seed=self.args.seed,
+            )
+            lang_text_sizes[lang] = est_total
+            lang_text_bpr[lang] = est_bpr
+            log.debug(
+                f"[{lang}] {lang_row_counts[lang]:,} rows, "
+                f"~{est_total / 1e6:.1f} MB text "
+                f"(~{est_bpr:.0f} text bytes/row)"
+            )
+
+        total_input_text_bytes = sum(lang_text_sizes.values())
+        log.info(
+            f"Total input corpus: ~{total_input_text_bytes / 1e9:.3f} GB text "
+            f"across {sum(lang_row_counts.values()):,} rows."
+        )
+
+        if self.total_target_bytes >= total_input_text_bytes:
+            log.warning(
+                f"Target size ({self.args.total_size_gb} GB text) >= estimated "
+                f"input size ({total_input_text_bytes / 1e9:.3f} GB text). "
+                "Will use all available rows per language."
+            )
+
+        # ------------------------------------------------------------------ #
+        # 3. Compute proportions with temperature + cap
+        # ------------------------------------------------------------------ #
+        proportions = _calculate_proportions(
+            lang_text_sizes,
+            self.args.sampling_temp,
+            cap=DEFAULT_CAP,
+        )
+        log.info(
+            "Language proportions (based on text bytes):\n"
+            + "\n".join(
+                f"  {lg}: {p*100:.2f}%" for lg, p in sorted(proportions.items())
+            )
+        )
+
+        # ------------------------------------------------------------------ #
+        # 4. Convert proportions → target row counts with redistribution
+        #    Each language's text-byte budget is converted to rows using
+        #    that language's estimated text_bytes_per_row.
+        #
+        #    Languages that are exhausted (budget > available) can't use
+        #    their full allocation.  The surplus text-byte budget is
+        #    redistributed proportionally among non-exhausted languages.
+        #    This repeats until stable or a maximum number of iterations.
+        # ------------------------------------------------------------------ #
+        MAX_REDIST_ITERS = 20
+
+        # Track which languages are "frozen" (exhausted or floored)
+        frozen: Dict[str, int] = {}       # lang → final row count
+        active_proportions = dict(proportions)  # lang → current proportion
+        remaining_budget = float(self.total_target_bytes)
+
+        for iteration in range(MAX_REDIST_ITERS):
+            newly_frozen = {}
+
+            for lang, prop in list(active_proportions.items()):
+                lang_text_budget = remaining_budget * prop
+                bpr = lang_text_bpr[lang]
+                if bpr > 0:
+                    estimated_rows = int(lang_text_budget / bpr)
+                else:
+                    estimated_rows = 0
+
+                floored_rows = max(estimated_rows, self.args.min_rows_floor)
+                available = lang_row_counts[lang]
+
+                if floored_rows >= available:
+                    # Exhausted: freeze at available, reclaim surplus
+                    newly_frozen[lang] = available
+                    if floored_rows > available:
+                        log.debug(
+                            f"[{lang}] iter {iteration}: requested "
+                            f"{floored_rows:,} > available {available:,}. "
+                            f"Freezing at {available:,}."
+                        )
+
+            if not newly_frozen:
+                # Nothing new to freeze — allocate final rows for active langs
+                break
+
+            # Freeze newly exhausted languages and reclaim their budget
+            for lang, rows in newly_frozen.items():
+                frozen[lang] = rows
+                # Reclaim the text bytes that this language actually uses
+                remaining_budget -= rows * lang_text_bpr[lang]
+                del active_proportions[lang]
+
+            # Re-normalise active proportions
+            active_total = sum(active_proportions.values())
+            if active_total > 0:
+                active_proportions = {
+                    lg: p / active_total for lg, p in active_proportions.items()
+                }
+            else:
+                break
+
+            log.info(
+                f"Redistribution iter {iteration}: froze {len(newly_frozen)} "
+                f"language(s), {len(active_proportions)} still active, "
+                f"~{remaining_budget / 1e9:.2f} GB budget remaining."
+            )
+
+        # Final allocation for still-active languages
+        target_rows: Dict[str, int] = dict(frozen)
+        for lang, prop in active_proportions.items():
+            lang_text_budget = remaining_budget * prop
+            bpr = lang_text_bpr[lang]
+            if bpr > 0:
+                estimated_rows = int(lang_text_budget / bpr)
+            else:
+                estimated_rows = 0
+            floored_rows = max(estimated_rows, self.args.min_rows_floor)
+            capped_rows = min(floored_rows, lang_row_counts[lang])
+            target_rows[lang] = capped_rows
+
+        # Summary logging
+        total_target_text = sum(
+            target_rows[lg] * lang_text_bpr[lg] for lg in target_rows
+        )
+        log.info(
+            f"Allocation complete after redistribution: "
+            f"~{total_target_text / 1e9:.2f} GB text across "
+            f"{sum(target_rows.values()):,} rows."
+        )
+        log.info(
+            "Target row counts:\n"
+            + "\n".join(
+                f"  {lg}: {n:,} / {lang_row_counts[lg]:,} available"
+                for lg, n in sorted(target_rows.items())
+            )
+        )
+
+        # ------------------------------------------------------------------ #
+        # 5. Compute common schema across languages
+        #    Reading schemas from every file on a parallel FS is very slow,
+        #    so we sample one file per language — the schema should be
+        #    consistent within a single corpus source.
+        # ------------------------------------------------------------------ #
+        schema_sample_files = [files[0] for files in lang_files.values()]
+        log.info(
+            f"Computing common schema from {len(schema_sample_files)} files "
+            f"(1 per language)…"
+        )
+        common_schema = get_common_schema(schema_sample_files)
+        
+        log.info("Common schema across all languages:")
+        for field in common_schema:
+            if pa.types.is_struct(field.type):
+                subfields = [field.type.field(i).name for i in range(field.type.num_fields)]
+                log.info(f"  {field.name} (struct): {subfields}")
+            else:
+                log.info(f"  {field.name}: {field.type}")
+        
+        # ------------------------------------------------------------------ #
+        # 6. Sample and write
+        # ------------------------------------------------------------------ #
+        manifest = {}
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        for lang, n_rows in tqdm(target_rows.items(), desc="Sampling languages"):
+            out_file = self.output_dir / lang / "data.parquet"
+
+            if out_file.exists():
+                log.info(f"[{lang}] Output already exists, skipping.")
+                manifest[lang] = {"status": "skipped", "output": str(out_file)}
+                continue
+
+            log.info(f"[{lang}] Sampling {n_rows:,} rows → {out_file}")
+            written = sample_language(
+                lang=lang,
+                parquet_files=lang_files[lang],
+                target_rows=n_rows,
+                output_path=out_file,
+                seed=self.args.seed,
+                common_schema=common_schema,
+                keep_columns=self.args.columns,
+            )
+            manifest[lang] = {
+                "status": "ok",
+                "rows_written": written,
+                "rows_available": lang_row_counts[lang],
+                "estimated_text_bytes": lang_text_sizes[lang],
+                "text_bytes_per_row": lang_text_bpr[lang],
+                "output": str(out_file),
+            }
+            log.info(f"[{lang}] Wrote {written:,} rows.")
+
+        # ------------------------------------------------------------------ #
+        # 7. Save manifest
+        # ------------------------------------------------------------------ #
+        total_parquet = sum(total_parquet_bytes(files) for files in lang_files.values())
+        manifest_path = self.output_dir / "sampling_manifest.json"
+        with open(manifest_path, "w", encoding="utf-8") as f:
+            json.dump(
+                {
+                    "args": vars(self.args),
+                    "total_input_parquet_gb": total_parquet / 1e9,
+                    "total_input_text_gb": total_input_text_bytes / 1e9,
+                    "target_text_gb": self.args.total_size_gb,
+                    "schema": [
+                        {"name": f.name, "type": str(f.type)} for f in common_schema
+                    ],
+                    "languages": manifest,
+                },
+                f,
+                indent=2,
+            )
+        log.info(f"Manifest saved to {manifest_path}")
+        log.info("--- Sampling finished ---")
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Create a sampled copy of a parquet corpus. "
+            "In the default multilingual mode the input directory must contain "
+            "one subdirectory per language code, each holding one or more .parquet files. "
+            "In monolingual mode (--monolingual) the input directory contains "
+            ".parquet files directly, with no subdirectories. "
+            "Language proportions are determined from UTF-8 text byte sizes "
+            "(estimated by sampling) rather than on-disk parquet sizes."
+        ),
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    parser.add_argument(
+        "--monolingual",
+        action="store_true",
+        default=False,
+        help=(
+            "Enable monolingual mode. The input directory should contain .parquet "
+            "files directly (no language subdirectories). The output is a single "
+            "data.parquet file in --output_dir. "
+            "Temperature sampling and the per-language cap are not applied."
+        ),
+    )
+
+    parser.add_argument(
+        "--lang_subdir",
+        type=str,
+        default="",
+        help=(
+            "Optional subdirectory name to look for parquet files within each "
+            "language directory (multilingual mode only). "
+            "E.g., '--lang_subdir train' will look for parquet files in "
+            "<input_dir>/<lang_code>/train/*.parquet. "
+            "Ignored in monolingual mode."
+        ),
+    )
+
+    parser.add_argument(
+        "--input_dir",
+        type=str,
+        required=True,
+        help=(
+            "Root directory of the source corpus. In multilingual mode this must "
+            "contain per-language subdirectories; in monolingual mode it must "
+            "contain .parquet files directly."
+        ),
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        required=True,
+        help="Root directory where the sampled corpus will be written.",
+    )
+    parser.add_argument(
+        "--total_size_gb",
+        type=float,
+        required=True,
+        help=(
+            "Target total size in GB of raw UTF-8 text. This is measured against "
+            "the estimated text byte content (not on-disk parquet size). "
+            "If this exceeds the estimated input text size, all available rows "
+            "are used."
+        ),
+    )
+    parser.add_argument(
+        "--text_column",
+        type=str,
+        default=DEFAULT_TEXT_COLUMN,
+        help="Name of the text column in the parquet files.",
+    )
+    parser.add_argument(
+        "--text_sample_rows",
+        type=int,
+        default=DEFAULT_TEXT_SAMPLE_ROWS,
+        help=(
+            "Number of rows to sample per language for estimating average text "
+            "byte size. Higher values give more accurate estimates but take "
+            "longer on large corpora."
+        ),
+    )
+    parser.add_argument(
+        "--sampling_temp",
+        type=float,
+        default=DEFAULT_TEMP,
+        help=(
+            "Temperature for language proportion sampling (multilingual mode only). "
+            "T=1.0 → proportional to text byte sizes. "
+            "T>1.0 → upsamples smaller languages (flattens distribution). "
+            "Uses the same size^(1/T) formula as corpus_downloader.py."
+        ),
+    )
+    parser.add_argument(
+        "--min_rows_floor",
+        type=int,
+        default=DEFAULT_MIN_ROWS,
+        help=(
+            "Minimum number of rows to sample per language. "
+            "If the proportional allocation is below this value the floor is "
+            "used instead (capped at whatever is available). "
+            "Will NOT oversample beyond the available rows."
+        ),
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=DEFAULT_SEED,
+        help="Random seed for reproducible sampling.",
+    )
+    parser.add_argument(
+        "--columns",
+        type=str,
+        nargs="+",
+        default=None,
+        help=(
+            "Keep only these columns in the output parquet files. "
+            "If not specified, all columns are kept. "
+            "The text column (--text_column) is always included."
+        ),
+    )
+
+    args = parser.parse_args()
+
+    if args.total_size_gb <= 0:
+        parser.error("--total_size_gb must be positive.")
+    if args.sampling_temp <= 0:
+        parser.error("--sampling_temp must be positive.")
+    if args.min_rows_floor < 0:
+        parser.error("--min_rows_floor must be non-negative.")
+    if args.text_sample_rows <= 0:
+        parser.error("--text_sample_rows must be positive.")
+
+    # Ensure text column is always in the keep list
+    if args.columns is not None and args.text_column not in args.columns:
+        args.columns.append(args.text_column)
+
+    return args
+
+
+def main():
+    args = parse_args()
+    random.seed(args.seed)
+    log.info(f"Starting corpus sampler with args: {json.dumps(vars(args), indent=2)}")
+    sampler = CorpusSampler(args)
+    sampler.run()
+
+
+if __name__ == "__main__":
+    main()

lm_training_mixture/metadata.json

@@ -0,0 +1,281 @@
+{
+  "sources": [
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/HuggingFaceFW/fineweb-edu/data",
+      "input_weight": 0.3684171745560573,
+      "text_field": "text",
+      "docs": 1842655,
+      "text_bytes": 9224926152,
+      "actual_byte_fraction": 0.36949816550749137
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/rus_Cyrl",
+      "input_weight": 0.1063567751918401,
+      "text_field": "text",
+      "docs": 531387,
+      "text_bytes": 4521169731,
+      "actual_byte_fraction": 0.18109238968707772
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/spa_Latn",
+      "input_weight": 0.024462900390522208,
+      "text_field": "text",
+      "docs": 122231,
+      "text_bytes": 422520665,
+      "actual_byte_fraction": 0.01692377890446936
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/deu_Latn",
+      "input_weight": 0.02375764465637204,
+      "text_field": "text",
+      "docs": 118340,
+      "text_bytes": 352848302,
+      "actual_byte_fraction": 0.014133099619791223
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/fra_Latn",
+      "input_weight": 0.020599783160177264,
+      "text_field": "text",
+      "docs": 103496,
+      "text_bytes": 363817121,
+      "actual_byte_fraction": 0.01457244823153106
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/cmn_Hani",
+      "input_weight": 0.019147166871927666,
+      "text_field": "text",
+      "docs": 95805,
+      "text_bytes": 326062469,
+      "actual_byte_fraction": 0.013060211231091846
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/jpn_Jpan",
+      "input_weight": 0.01265249839475374,
+      "text_field": "text",
+      "docs": 63316,
+      "text_bytes": 203932098,
+      "actual_byte_fraction": 0.008168361985505676
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/ita_Latn",
+      "input_weight": 0.011947242660603574,
+      "text_field": "text",
+      "docs": 59676,
+      "text_bytes": 165025109,
+      "actual_byte_fraction": 0.006609968907442567
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/por_Latn",
+      "input_weight": 0.011905137840654311,
+      "text_field": "text",
+      "docs": 59460,
+      "text_bytes": 188799748,
+      "actual_byte_fraction": 0.007562245961085789
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/tur_Latn",
+      "input_weight": 0.009410427258660436,
+      "text_field": "text",
+      "docs": 47074,
+      "text_bytes": 152005957,
+      "actual_byte_fraction": 0.006088495596849155
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/ind_Latn",
+      "input_weight": 0.009126219724002906,
+      "text_field": "text",
+      "docs": 45970,
+      "text_bytes": 236317338,
+      "actual_byte_fraction": 0.009465530827006428
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/pol_Latn",
+      "input_weight": 0.008799907369396112,
+      "text_field": "text",
+      "docs": 43902,
+      "text_bytes": 106893993,
+      "actual_byte_fraction": 0.00428156645012356
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/ukr_Cyrl",
+      "input_weight": 0.006778876011831456,
+      "text_field": "text",
+      "docs": 34088,
+      "text_bytes": 210911553,
+      "actual_byte_fraction": 0.00844791932572167
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/nld_Latn",
+      "input_weight": 0.006494668477173925,
+      "text_field": "text",
+      "docs": 32404,
+      "text_bytes": 70708339,
+      "actual_byte_fraction": 0.0028321746013020882
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/ron_Latn",
+      "input_weight": 0.005789412743023758,
+      "text_field": "text",
+      "docs": 29203,
+      "text_bytes": 97479339,
+      "actual_byte_fraction": 0.0039044688642384333
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/arb_Arab",
+      "input_weight": 0.005410469363480385,
+      "text_field": "text",
+      "docs": 27292,
+      "text_bytes": 168441711,
+      "actual_byte_fraction": 0.006746818585203459
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/hun_Latn",
+      "input_weight": 0.005084157008873592,
+      "text_field": "text",
+      "docs": 25066,
+      "text_bytes": 98950889,
+      "actual_byte_fraction": 0.003963410802254345
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/vie_Latn",
+      "input_weight": 0.004326270249786845,
+      "text_field": "text",
+      "docs": 21306,
+      "text_bytes": 108891716,
+      "actual_byte_fraction": 0.004361583891079668
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/ces_Latn",
+      "input_weight": 0.004284165429837581,
+      "text_field": "text",
+      "docs": 21696,
+      "text_bytes": 77089494,
+      "actual_byte_fraction": 0.0030877674404716214
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/ell_Grek",
+      "input_weight": 0.0035262786707508345,
+      "text_field": "text",
+      "docs": 17672,
+      "text_bytes": 108164216,
+      "actual_byte_fraction": 0.004332444371588943
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/fin_Latn",
+      "input_weight": 0.002347343712171451,
+      "text_field": "text",
+      "docs": 11721,
+      "text_bytes": 34189230,
+      "actual_byte_fraction": 0.0013694264384300613
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/tha_Thai",
+      "input_weight": 0.0023052388922221874,
+      "text_field": "text",
+      "docs": 11639,
+      "text_bytes": 86947590,
+      "actual_byte_fraction": 0.003482626795156756
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/slk_Latn",
+      "input_weight": 0.001978926537615394,
+      "text_field": "text",
+      "docs": 10015,
+      "text_bytes": 27627893,
+      "actual_byte_fraction": 0.0011066165313555415
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/bul_Cyrl",
+      "input_weight": 0.001926295512678814,
+      "text_field": "text",
+      "docs": 9513,
+      "text_bytes": 51667330,
+      "actual_byte_fraction": 0.002069499889441519
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/hrv_Latn",
+      "input_weight": 0.001694719002957864,
+      "text_field": "text",
+      "docs": 8395,
+      "text_bytes": 26289008,
+      "actual_byte_fraction": 0.0010529884000107458
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/kor_Hang",
+      "input_weight": 0.0016420879780212842,
+      "text_field": "text",
+      "docs": 8263,
+      "text_bytes": 29412658,
+      "actual_byte_fraction": 0.0011781040839381714
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/cat_Latn",
+      "input_weight": 0.0010315680887569606,
+      "text_field": "text",
+      "docs": 5087,
+      "text_bytes": 13853762,
+      "actual_byte_fraction": 0.0005549030485482628
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/hin_Deva",
+      "input_weight": 0.000989463268807697,
+      "text_field": "text",
+      "docs": 4928,
+      "text_bytes": 32306762,
+      "actual_byte_fraction": 0.0012940254583934075
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/heb_Hebr",
+      "input_weight": 0.0009368322438711172,
+      "text_field": "text",
+      "docs": 4665,
+      "text_bytes": 25031907,
+      "actual_byte_fraction": 0.0010026360713628977
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/ben_Beng",
+      "input_weight": 0.0007052557341501669,
+      "text_field": "text",
+      "docs": 3525,
+      "text_bytes": 23728899,
+      "actual_byte_fraction": 0.0009504449689401207
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/fineweb-2_0_1-quality_33-filterrobots/data/output/tam_Taml",
+      "input_weight": 0.0003789433795433733,
+      "text_field": "text",
+      "docs": 1831,
+      "text_bytes": 17154744,
+      "actual_byte_fraction": 0.0006871216455620517
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/HuggingFaceTB/finemath/finemath-4plus",
+      "input_weight": 0.15789307480973885,
+      "text_field": "text",
+      "docs": 789531,
+      "text_bytes": 4009353346,
+      "actual_byte_fraction": 0.1605919312315729
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/starcoderdata/thresholds/python/threshold_0",
+      "input_weight": 0.10526204987315925,
+      "text_field": "content",
+      "docs": 525657,
+      "text_bytes": 2494231654,
+      "actual_byte_fraction": 0.09990475862009003
+    },
+    {
+      "path": "/capstor/store/cscs/swissai/infra01/datasets/swiss-ai/starcoderdata/thresholds/javascript/threshold_0",
+      "input_weight": 0.052631024936579625,
+      "text_field": "content",
+      "docs": 263191,
+      "text_bytes": 889343870,
+      "actual_byte_fraction": 0.03562206602587152
+    }
+  ],
+  "total_docs": 5000000,
+  "total_text_bytes": 24966094593,
+  "num_files": 101,
+  "val_docs": 0,
+  "seed": 42
+}

lm_training_mixture/shard_00001.parquet

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

lm_training_mixture/shard_00004.parquet

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

lm_training_mixture/shard_00009.parquet

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

lm_training_mixture/shard_00010.parquet

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

lm_training_mixture/shard_00012.parquet

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

lm_training_mixture/shard_00017.parquet

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

lm_training_mixture/shard_00021.parquet

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

lm_training_mixture/shard_00025.parquet

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

lm_training_mixture/shard_00026.parquet

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

lm_training_mixture/shard_00030.parquet

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

lm_training_mixture/shard_00035.parquet

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

lm_training_mixture/shard_00038.parquet

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

lm_training_mixture/shard_00040.parquet

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

lm_training_mixture/shard_00044.parquet

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

lm_training_mixture/shard_00047.parquet

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

lm_training_mixture/shard_00048.parquet

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

lm_training_mixture/shard_00049.parquet

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

lm_training_mixture/shard_00051.parquet

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

lm_training_mixture/shard_00056.parquet

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

lm_training_mixture/shard_00067.parquet

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

lm_training_mixture/shard_00070.parquet

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

lm_training_mixture/shard_00073.parquet

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

lm_training_mixture/shard_00074.parquet

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

lm_training_mixture/shard_00079.parquet

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

lm_training_mixture/shard_00081.parquet

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

lm_training_mixture/shard_00084.parquet

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

lm_training_mixture/shard_00091.parquet

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

lm_training_mixture/shard_00096.parquet

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

tokenizer_training_pool/fineweb2/mic_Latn.parquet

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

tokenizer_training_pool/starcoder/assembly.parquet

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

tokenizer_training_pool/starcoder/c-sharp.parquet

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

tokenizer_training_pool/starcoder/c.parquet

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

tokenizer_training_pool/starcoder/dart.parquet

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

tokenizer_training_pool/starcoder/haskell.parquet

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

tokenizer_training_pool/starcoder/java.parquet

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

tokenizer_training_pool/starcoder/lua.parquet

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

tokenizer_training_pool/starcoder/mathematica.parquet

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

tokenizer_training_pool/starcoder/protocol-buffer.parquet

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

tokenizer_training_pool/starcoder/python.parquet

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

tokenizer_training_pool/starcoder/scala.parquet

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

tokenizer_training_pool/starcoder/stan.parquet

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

tokenizer_training_pool/starcoder/tcl.parquet

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

tokenizer_training_pool/tokenizer_dataset_sampler.py

@@ -0,0 +1,591 @@
+#!/usr/bin/env python3
+"""
+tokenizer_sampler.py
+
+Creates a tokenizer training dataset by sampling from multiple corpus sources
+(both monolingual and multilingual). Each source is sampled independently with
+its own temperature parameter and size target.
+
+Language proportions are determined from **UTF-8 text byte sizes** (measured
+from the text column) rather than on-disk parquet byte sizes, ensuring
+consistent cross-lingual sampling regardless of compression ratios or
+metadata overhead.
+
+Config file structure (JSON):
+{
+  "sources": [
+    {
+      "name": "fineweb2",
+      "path": "/path/to/fineweb2_sample",
+      "is_monolingual": false,
+      "target_size_gb": 5.0,
+      "sampling_temp": 5.0,
+      "min_samples_per_language": 1000,
+      "text_column": "text"
+    },
+    {
+      "name": "finemath",
+      "path": "/path/to/finemath_sample",
+      "is_monolingual": true,
+      "target_size_gb": 2.0,
+      "min_samples_per_language": 500,
+      "text_column": "text"
+    }
+  ],
+  "output_dir": "/path/to/tokenizer_corpus",
+  "seed": 42
+}
+
+Output structure:
+    output_dir/
+        <source_name>/
+            <lang_code>.parquet  (for multilingual sources)
+            data.parquet          (for monolingual sources)
+        ...
+        sampling_stats.json
+
+For monolingual sources, the source name itself serves as the "language"
+identifier in the output structure.
+"""
+
+import json
+import math
+import random
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import pyarrow as pa
+import pyarrow.compute as pc
+import pyarrow.parquet as pq
+from tqdm import tqdm
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Defaults
+# ---------------------------------------------------------------------------
+
+DEFAULT_TEMP = 3.0
+DEFAULT_CAP = 0.5
+DEFAULT_MIN_SAMPLES = 1000
+DEFAULT_SEED = 42
+DEFAULT_TEXT_COLUMN = "text"
+
+# ---------------------------------------------------------------------------
+# Helper functions
+# ---------------------------------------------------------------------------
+
+def validate_parquet_files(files: List[Path]) -> List[Path]:
+    """
+    Return only the files that can be opened as valid parquet files.
+    Corrupt or invalid files are logged as warnings and excluded.
+    """
+    valid = []
+    for f in files:
+        try:
+            pq.ParquetFile(f)
+            valid.append(f)
+        except Exception as e:
+            log.warning(f"Skipping corrupt/invalid parquet file '{f}': {e}")
+    return valid
+
+
+def total_parquet_bytes(files: List[Path]) -> int:
+    """Return the sum of on-disk sizes (bytes) for a list of parquet files."""
+    return sum(f.stat().st_size for f in files)
+
+
+def count_rows(files: List[Path]) -> int:
+    """Count total rows across a list of parquet files without loading data."""
+    total = 0
+    for f in files:
+        pf = pq.ParquetFile(f)
+        total += pf.metadata.num_rows
+    return total
+
+
+def _measure_text_bytes_in_table(table: pa.Table, text_column: str) -> int:
+    """Sum UTF-8 byte lengths of the text column in an Arrow table."""
+    col = table.column(text_column)
+    # Cast to binary to get raw UTF-8 byte lengths (not character counts)
+    byte_lengths = pc.binary_length(col.cast(pa.large_binary()))
+    return pc.sum(byte_lengths, skip_nulls=True).as_py() or 0
+
+
+def measure_text_bytes(
+    files: List[Path],
+    text_column: str,
+) -> Tuple[int, float]:
+    """
+    Measure total UTF-8 text bytes across all files by reading the text column.
+
+    Returns (total_text_bytes, avg_text_bytes_per_row).
+    """
+    total_text_bytes = 0
+    total_rows = 0
+    for f in files:
+        table = pq.read_table(f, columns=[text_column])
+        total_text_bytes += _measure_text_bytes_in_table(table, text_column)
+        total_rows += len(table)
+
+    avg = total_text_bytes / total_rows if total_rows > 0 else 0.0
+    return total_text_bytes, avg
+
+
+def _calculate_proportions(
+    original_sizes: Dict[str, float],
+    temperature: float,
+    cap: float = DEFAULT_CAP,
+) -> Dict[str, float]:
+    """
+    Compute per-language sampling proportions with temperature scaling and
+    a per-language cap.
+    """
+    if not original_sizes:
+        return {}
+
+    # --- 1. Temperature scaling ---
+    if temperature == 1.0:
+        powered = dict(original_sizes)
+    else:
+        log.debug(f"Applying temperature {temperature} to size-based proportions.")
+        powered = {lg: size ** (1.0 / temperature) for lg, size in original_sizes.items()}
+
+    total_powered = sum(powered.values())
+    if total_powered == 0:
+        return {}
+
+    proportions: Dict[str, float] = {
+        lg: p / total_powered for lg, p in powered.items()
+    }
+
+    # --- 2. Cap ---
+    capping_needed = any(p > cap for p in proportions.values())
+    if capping_needed:
+        for lg, prop in proportions.items():
+            if prop > cap:
+                log.warning(
+                    f"[{lg}] proportion {prop*100:.1f}% exceeds cap. "
+                    f"Capping at {cap*100:.0f}%."
+                )
+                proportions[lg] = cap
+
+        capped_total = sum(p for p in proportions.values() if p == cap)
+        remaining = 1.0 - capped_total
+        uncapped_powered_total = sum(
+            powered[lg] for lg, p in proportions.items() if p < cap
+        )
+        if uncapped_powered_total > 0:
+            for lg in proportions:
+                if proportions[lg] < cap:
+                    proportions[lg] = (powered[lg] / uncapped_powered_total) * remaining
+        elif remaining > 0:
+            log.warning("All languages are at the cap. Distribution may not sum to 1.")
+
+    # --- 3. Re-normalise ---
+    total = sum(proportions.values())
+    if not math.isclose(total, 1.0, rel_tol=1e-5):
+        log.debug(f"Proportions sum to {total:.6f}; re-normalising.")
+        proportions = {lg: p / total for lg, p in proportions.items()}
+
+    return proportions
+
+
+def cast_to_large_string(schema: pa.Schema) -> pa.Schema:
+    """Cast all string columns (including inside structs) to large_string."""
+    new_fields = []
+    for field in schema:
+        if pa.types.is_string(field.type):
+            new_fields.append(pa.field(field.name, pa.large_string()))
+        elif pa.types.is_struct(field.type):
+            subfields = []
+            for i in range(field.type.num_fields):
+                sf = field.type.field(i)
+                if pa.types.is_string(sf.type):
+                    subfields.append(pa.field(sf.name, pa.large_string()))
+                else:
+                    subfields.append(sf)
+            new_fields.append(pa.field(field.name, pa.struct(subfields)))
+        else:
+            new_fields.append(field)
+    return pa.schema(new_fields)
+
+
+def sample_rows(
+    parquet_files: List[Path],
+    target_rows: int,
+    output_path: Path,
+    seed: int,
+) -> int:
+    """
+    Sample target_rows from parquet_files and write to output_path.
+    Returns the actual number of rows written.
+    """
+    total_rows = count_rows(parquet_files)
+    actual_target = min(target_rows, total_rows)
+
+    if actual_target <= 0:
+        log.warning(f"target_rows={target_rows}, total_rows={total_rows}. Nothing to write.")
+        return 0
+
+    # Build sorted index set
+    rng = random.Random(seed)
+    selected = sorted(rng.sample(range(total_rows), actual_target))
+
+    # Materialise selected rows
+    collected_batches: List[pa.Table] = []
+    file_row_counts = [pq.ParquetFile(f).metadata.num_rows for f in parquet_files]
+    global_idx = 0
+    large_schema = None  # Will be set on first batch
+
+    for file_path, file_row_count in zip(parquet_files, file_row_counts):
+        file_start = global_idx
+        file_end = global_idx + file_row_count
+
+        local_indices = [
+            gi - file_start
+            for gi in selected
+            if file_start <= gi < file_end
+        ]
+
+        if local_indices:
+            pf = pq.ParquetFile(file_path)
+            
+            # Build large_string schema once, handling structs
+            if large_schema is None:
+                large_schema = cast_to_large_string(pf.schema_arrow)
+            
+            row_offset = 0
+            for rg in range(pf.metadata.num_row_groups):
+                rg_rows = pf.metadata.row_group(rg).num_rows
+                rg_needed = [
+                    li - row_offset
+                    for li in local_indices
+                    if row_offset <= li < row_offset + rg_rows
+                ]
+                if rg_needed:
+                    batch = pf.read_row_group(rg)
+                    # Cast to large_string BEFORE take to avoid overflow
+                    batch = batch.cast(large_schema)
+                    filtered = batch.take(pa.array(rg_needed))
+                    collected_batches.append(filtered)
+                row_offset += rg_rows
+
+        global_idx = file_end
+
+    if not collected_batches:
+        log.warning(f"No rows collected despite target={actual_target}.")
+        return 0
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    table = pa.concat_tables(collected_batches)
+    pq.write_table(table, output_path, compression="snappy")
+
+    return len(table)
+
+
+# ---------------------------------------------------------------------------
+# Source discovery
+# ---------------------------------------------------------------------------
+
+def discover_source(source_path: Path, is_monolingual: bool) -> Dict[str, List[Path]]:
+    """
+    Discover parquet files in a source directory.
+    
+    For monolingual sources: returns {"monolingual": [list of parquet files]}
+    For multilingual sources: returns {lang_code: [list of parquet files], ...}
+    """
+    if is_monolingual:
+        parquets = validate_parquet_files(sorted(source_path.glob("*.parquet")))
+        if not parquets:
+            log.warning(f"No valid parquet files found in monolingual source '{source_path}'")
+            return {}
+        return {"monolingual": parquets}
+    else:
+        # Multilingual: expect subdirectories named by language code
+        langs: Dict[str, List[Path]] = {}
+        for subdir in sorted(source_path.iterdir()):
+            if not subdir.is_dir():
+                continue
+            parquets = validate_parquet_files(sorted(subdir.glob("*.parquet")))
+            if parquets:
+                langs[subdir.name] = parquets
+            else:
+                log.debug(f"Skipping '{subdir.name}': no valid parquet files found.")
+        return langs
+
+
+# ---------------------------------------------------------------------------
+# Main sampler
+# ---------------------------------------------------------------------------
+
+class TokenizerSampler:
+    def __init__(self, config_path: Path):
+        self.config_path = config_path
+        with open(config_path, 'r') as f:
+            self.config = json.load(f)
+        
+        self.output_dir = Path(self.config['output_dir'])
+        self.seed = self.config.get('seed', DEFAULT_SEED)
+        random.seed(self.seed)
+        
+        self.sources = self.config['sources']
+        
+    def run(self):
+        log.info(f"Starting tokenizer sampler with config: {self.config_path}")
+        
+        manifest = {
+            "config": self.config,
+            "sources": {}
+        }
+        
+        for source_config in self.sources:
+            source_name = source_config['name']
+            log.info(f"\n{'='*60}")
+            log.info(f"Processing source: {source_name}")
+            log.info(f"{'='*60}")
+            
+            source_manifest = self._process_source(source_config)
+            manifest["sources"][source_name] = source_manifest
+        
+        # Save manifest
+        manifest_path = self.output_dir / "sampling_stats.json"
+        with open(manifest_path, 'w', encoding='utf-8') as f:
+            json.dump(manifest, f, indent=2)
+        
+        log.info(f"\n{'='*60}")
+        log.info(f"Tokenizer sampling complete!")
+        log.info(f"Manifest: {manifest_path}")
+        log.info(f"{'='*60}")
+    
+    def _process_source(self, source_config: dict) -> dict:
+        """Process a single source and return its manifest."""
+        source_name = source_config['name']
+        source_path = Path(source_config['path'])
+        is_monolingual = source_config['is_monolingual']
+        target_size_gb = source_config['target_size_gb']
+        target_bytes = int(target_size_gb * (1024 ** 3))
+        sampling_temp = source_config.get('sampling_temp', DEFAULT_TEMP)
+        min_samples = source_config.get('min_samples_per_language', DEFAULT_MIN_SAMPLES)
+        text_column = source_config.get('text_column', DEFAULT_TEXT_COLUMN)
+        
+        # Discover files
+        lang_files = discover_source(source_path, is_monolingual)
+        if not lang_files:
+            log.error(f"[{source_name}] No valid files found. Skipping.")
+            return {"status": "skipped", "reason": "no valid files"}
+        
+        log.info(f"[{source_name}] Found {len(lang_files)} language(s): {sorted(lang_files.keys())}")
+        
+        # Measure text byte sizes (input is already a sample, so full read is fine)
+        log.info(f"[{source_name}] Measuring UTF-8 text bytes (column: '{text_column}')…")
+        lang_text_sizes: Dict[str, int] = {}
+        lang_text_bpr: Dict[str, float] = {}
+        lang_row_counts: Dict[str, int] = {}
+        
+        for lang, files in tqdm(lang_files.items(), desc=f"Measuring {source_name}"):
+            lang_row_counts[lang] = count_rows(files)
+            text_bytes, text_bpr = measure_text_bytes(files, text_column)
+            lang_text_sizes[lang] = text_bytes
+            lang_text_bpr[lang] = text_bpr
+            log.info(
+                f"  [{lang}] {lang_row_counts[lang]:,} rows, "
+                f"{text_bytes / 1e6:.1f} MB text "
+                f"(~{text_bpr:.0f} text bytes/row)"
+            )
+        
+        total_input_text_bytes = sum(lang_text_sizes.values())
+        log.info(
+            f"[{source_name}] Total: {total_input_text_bytes / 1e9:.3f} GB text"
+        )
+        
+        # Calculate proportions
+        if is_monolingual:
+            # Monolingual: single "language", no temperature needed
+            proportions = {"monolingual": 1.0}
+        else:
+            # Multilingual: apply temperature to text byte sizes
+            proportions = _calculate_proportions(
+                lang_text_sizes,
+                sampling_temp,
+                cap=DEFAULT_CAP,
+            )
+            log.info(
+                f"[{source_name}] Language proportions (T={sampling_temp}, text-byte-based):\n" +
+                "\n".join(f"  {lg}: {p*100:.2f}%" for lg, p in sorted(proportions.items()))
+            )
+        
+        # Calculate target rows per language with redistribution
+        # Languages that can't fill their budget have their surplus
+        # redistributed to languages with remaining capacity.
+        MAX_REDIST_ITERS = 20
+
+        frozen: Dict[str, int] = {}
+        active_proportions = dict(proportions)
+        remaining_budget = float(target_bytes)
+
+        for iteration in range(MAX_REDIST_ITERS):
+            newly_frozen = {}
+
+            for lang, prop in list(active_proportions.items()):
+                lang_text_budget = remaining_budget * prop
+                bpr = lang_text_bpr[lang]
+                if bpr > 0:
+                    estimated_rows = int(lang_text_budget / bpr)
+                else:
+                    estimated_rows = 0
+
+                floored_rows = max(estimated_rows, min_samples)
+                available = lang_row_counts[lang]
+
+                if floored_rows >= available:
+                    newly_frozen[lang] = available
+
+            if not newly_frozen:
+                break
+
+            for lang, rows in newly_frozen.items():
+                frozen[lang] = rows
+                remaining_budget -= rows * lang_text_bpr[lang]
+                del active_proportions[lang]
+
+            active_total = sum(active_proportions.values())
+            if active_total > 0:
+                active_proportions = {
+                    lg: p / active_total for lg, p in active_proportions.items()
+                }
+            else:
+                break
+
+            log.info(
+                f"  [{source_name}] Redistribution iter {iteration}: froze "
+                f"{len(newly_frozen)} language(s), "
+                f"{len(active_proportions)} still active, "
+                f"~{remaining_budget / 1e9:.2f} GB budget remaining."
+            )
+
+        target_rows: Dict[str, int] = dict(frozen)
+        for lang, prop in active_proportions.items():
+            lang_text_budget = remaining_budget * prop
+            bpr = lang_text_bpr[lang]
+            if bpr > 0:
+                estimated_rows = int(lang_text_budget / bpr)
+            else:
+                estimated_rows = 0
+            floored_rows = max(estimated_rows, min_samples)
+            capped_rows = min(floored_rows, lang_row_counts[lang])
+            target_rows[lang] = capped_rows
+
+        total_target_text = sum(
+            target_rows[lg] * lang_text_bpr[lg] for lg in target_rows
+        )
+        log.info(
+            f"[{source_name}] Allocation complete: "
+            f"~{total_target_text / 1e9:.2f} GB text across "
+            f"{sum(target_rows.values()):,} rows."
+        )
+        
+        log.info(
+            f"[{source_name}] Target rows:\n" +
+            "\n".join(f"  {lg}: {n:,}" for lg, n in sorted(target_rows.items()))
+        )
+        
+        # Sample and write
+        source_output_dir = self.output_dir / source_name
+        source_output_dir.mkdir(parents=True, exist_ok=True)
+        
+        lang_manifest = {}
+        
+        for lang, n_rows in tqdm(target_rows.items(), desc=f"Sampling {source_name}"):
+            if is_monolingual:
+                out_file = source_output_dir / "data.parquet"
+            else:
+                out_file = source_output_dir / f"{lang}.parquet"
+            
+            if out_file.exists():
+                log.info(f"  [{lang}] Output exists, skipping.")
+                try:
+                    existing_rows = count_rows([out_file])
+                except Exception as e:
+                    log.warning(f"  [{lang}] Could not count rows in existing file: {e}")
+                    existing_rows = None
+                
+                lang_manifest[lang] = {
+                    "status": "skipped",
+                    "rows_written": existing_rows,
+                    "rows_available": lang_row_counts[lang],
+                    "output": str(out_file)
+                }
+                continue
+            
+            # Derive a per-language seed to avoid identical index sets
+            lang_seed = self.seed + hash(lang) % (2**31)
+            
+            written = sample_rows(
+                parquet_files=lang_files[lang],
+                target_rows=n_rows,
+                output_path=out_file,
+                seed=lang_seed,
+            )
+            
+            lang_manifest[lang] = {
+                "status": "ok",
+                "rows_written": written,
+                "rows_available": lang_row_counts[lang],
+                "text_bytes": lang_text_sizes[lang],
+                "text_bytes_per_row": lang_text_bpr[lang],
+                "output": str(out_file),
+            }
+            log.info(f"  [{lang}] Wrote {written:,} rows → {out_file.name}")
+        
+        return {
+            "status": "ok",
+            "total_input_text_gb": total_input_text_bytes / 1e9,
+            "target_text_gb": target_size_gb,
+            "languages": lang_manifest,
+        }
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main():
+    import argparse
+    
+    parser = argparse.ArgumentParser(
+        description=(
+            "Sample a tokenizer training dataset from multiple corpus sources. "
+            "Language proportions are determined from UTF-8 text byte sizes."
+        ),
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    
+    parser.add_argument(
+        "config",
+        type=str,
+        help="Path to JSON configuration file.",
+    )
+    
+    args = parser.parse_args()
+    
+    config_path = Path(args.config)
+    if not config_path.exists():
+        log.error(f"Config file not found: {config_path}")
+        return
+    
+    sampler = TokenizerSampler(config_path)
+    sampler.run()
+
+
+if __name__ == "__main__":
+    main()