README.md

metadata

pretty_name: ViTco
language:
  - vi
license: other
license_name: per-document-open-permissive-attribution
license_link: https://github.com/tamnd/gao/blob/main/law/posture.go
size_categories:
  - 100M<n<1B
task_categories:
  - text-generation
  - fill-mask
multilinguality:
  - monolingual
language_creators:
  - found
annotations_creators:
  - no-annotation
source_datasets:
  - original
tags:
  - vietnamese
  - pretraining
  - parquet
  - web
  - corpus
configs:
  - config_name: default
    data_files:
      - split: train
        path: data/*/*.parquet
  - config_name: hplt3
    data_files:
      - split: train
        path: data/hplt3/*.parquet
  - config_name: fineweb2
    data_files:
      - split: train
        path: data/fineweb2/*.parquet
  - config_name: glotcc
    data_files:
      - split: train
        path: data/glotcc/*.parquet
  - config_name: finepdfs
    data_files:
      - split: train
        path: data/finepdfs/*.parquet

ViTco

165,847,195 Vietnamese documents from 4 public corpora, 370.2 GB of Parquet, one schema

This dataset is the pinned public Vietnamese corpora as gao read them, every source put to one contract and one schema, before any cleaning.

Contents

• What is it
• What is in it
• Where the text came from
• How it is laid out
• Reading it
• What you can build with it
• One row
• The columns
• What this repo is
• What ships and what does not
• Things to know before you use it
• What this is not
• Citation
• Where this comes from

What is it

Vietnamese is a language with a lot of public text and nowhere to get it from at once. HPLT v3 is not on the Hub at all, it is sorted zstd JSONL on a datalake behind a per language map file. GlotCC is Parquet with its own column names. fineweb-2 is Parquet with different ones. FinePDFs is text pulled out of PDFs with a third set. The four disagree about what a document is, about what the url field is called, and in places about whether there is one.

This repo is those corpora after that has been sorted out. Every document from every source is one row of the same schema, carrying its own url, its own host, its own license class, and a locator that says which file of which upstream corpus it came out of. Read one source or read all four and it is the same query either way.

Nothing has been dropped for quality and nothing has been deduplicated. Those are the two decisions that most change what a model trained on a corpus turns out to be, they are both irreversible, and neither of them is ours to make for somebody else. What is here instead is the columns to make them with: lang_score, n_syllables, diacritics, host, license_class, and the whole upstream_fields map each source arrived carrying.

For scale, the largest single Vietnamese corpus published on the Hub is the vie_Latn config of fineweb-2, at 61,092,524 documents and 130.2 GB. This repo is at 165,847,195 documents and 370.2 GB, and the ingest is not finished.

What is in it

source	documents	parts	input files	size	pinned at
hplt3	120,230,406	444	9	210.3 GB	hplt3-5b2785d5b11c
fineweb2	31,165,817	174	14	79.0 GB	fineweb2-af9c13333eb9
glotcc	13,232,715	113	27	53.9 GB	glotcc-9ad140b6be3a
finepdfs	1,218,257	54	3	26.9 GB	finepdfs-220bac3acbf0
total	165,847,195	785		370.2 GB

Every count here is the row count in a part's own Parquet footer, added up. None of it is what a run reported writing, because a run that died between pushing a part and writing down that it had is exactly the case a count has to be right about.

The per part version of this table is parts.csv at the root of the repo, which is one row per file with its source, its snapshot, the input file it came from, its document count and its size. It is a CSV so that it can be read without a Parquet reader, and it is small enough to open in anything.

The repo grows while ingests run, so these numbers are the ones from the last time gao store index was run against it rather than a sealed total. The counts in parts.csv and the counts here always agree, because they are generated together.

Where the text came from

Four public corpora, pinned at a revision, read once, and written out under the schema below. Nothing here was crawled by us. Every one of them has its own card, its own paper in most cases, and its own terms, and the links are the place to read them.

HPLT v3, as hplt3

Web text from the High Performance Language Technologies project, built out of Internet Archive and Common Crawl WARCs and cleaned and language identified per document. It is the largest of the four here and the only one that is not on the Hub: the data is sorted zstd JSONL on the Sigma2 NIRD datalake, behind a per language map file, which is most of the reason a Vietnamese corpus assembled by hand usually does not include it.

120,230,406 documents here, 210.3 GB of Parquet, pinned at hplt3-5b2785d5b11c. Upstream: https://hplt-project.org/datasets/v3.0

fineweb-2, as fineweb2

The multilingual half of FineWeb, which is Common Crawl put through the FineWeb recipe with the filters retuned per language. It is the largest single Vietnamese corpus published on the Hub and the one most Vietnamese web text work already starts from.

31,165,817 documents here, 79.0 GB of Parquet, pinned at fineweb2-af9c13333eb9. Upstream: https://huggingface.co/datasets/HuggingFaceFW/fineweb-2

GlotCC v1, as glotcc

A Common Crawl derived corpus from CIS at LMU Munich, built for language coverage rather than for volume, with GlotLID doing the identification. Its documents run shorter than the other web sources and its tail of hosts runs wider, which is what makes it worth having beside them rather than under them.

13,232,715 documents here, 53.9 GB of Parquet, pinned at glotcc-9ad140b6be3a. Upstream: https://huggingface.co/datasets/cis-lmu/GlotCC-V1

FinePDFs, as finepdfs

Text extracted from PDFs instead of from HTML. It is the smallest source here and the least like the others: government circulars, legal texts, filings and course material, written to be read on a page rather than scrolled, and long. If the interesting part of Vietnamese for a piece of work is the formal register, this is where it is.

1,218,257 documents here, 26.9 GB of Parquet, pinned at finepdfs-220bac3acbf0. Upstream: https://huggingface.co/datasets/HuggingFaceFW/finepdfs

Two more are pinned in the ingest manifest and are not here. CulturaX is gated on the Hub and the terms were never granted to anybody on this project, so not one byte of it has been read and it is dropped rather than pending. It is mC4 and OSCAR, both built out of Common Crawl, so it went over the same pages the sources above went over, though that is worth less than it sounds: identity here is a hash of the extracted text, and two Common Crawl derivatives in this repo share under one percent of the smaller of them, because two extractors rarely agree on every byte of a page. MADLAD-400 ships as gzipped JSONL rather than Parquet, so it costs a rewrite that the Parquet sources do not, and it is queued behind them.

The manifest with every pinned revision, every input file and its byte count is at https://github.com/tamnd/gao/blob/main/harvest/manifest.json.

How it is laid out

README.md
parts.csv
data/hplt3/
  hplt3-5b2785d5b11c-00000-00000.parquet
  ... and 443 more
data/fineweb2/
  fineweb2-af9c13333eb9-00000-00000.parquet
  ... and 173 more
data/glotcc/
  glotcc-9ad140b6be3a-00000-00000.parquet
  ... and 112 more
data/finepdfs/
  finepdfs-220bac3acbf0-00000-00000.parquet
  ... and 53 more

One directory per source, and the file name is the snapshot, the input file of the source the part came out of, and the part. The snapshot is the source and the revision it was pinned at, so re-pinning a source puts its new parts beside the old ones in the same directory under a different name rather than moving the directory. That is deliberate: the directory is the config name somebody writes in a load_dataset call, and a name that moves every time a source is re-pinned is a name nobody can write down.

The directories are named plainly rather than Hive style. A Hive path spells the directory snapshot=hplt3-5b2785d5b11c, and then every reader who globs the repo gets a snapshot column in their result set that is in no file, sitting next to a source column that is, so the first thing the layout teaches them is a distinction they did not ask for.

Reading it

The files are Parquet and they are readable in place. Nothing below downloads the repo, and none of it needs a token, because the repo is public.

DuckDB

Install DuckDB, then:

INSTALL httpfs;
LOAD httpfs;

What is in the repo, without opening a single Parquet file. parts.csv is a CSV of one row per part, so this is a few tens of kilobytes of reading.

SELECT source, count(*) AS parts, sum(documents) AS documents,
       round(sum(bytes) / 1e9, 1) AS gb
FROM 'hf://datasets/open-index/vitco/parts.csv'
GROUP BY source ORDER BY documents DESC;

┌──────────┬───────┬───────────┬────────┐
│  source  │ parts │ documents │   gb   │
│ varchar  │ int64 │  int128   │ double │
├──────────┼───────┼───────────┼────────┤
│ hplt3    │   444 │ 120230406 │  210.3 │
│ fineweb2 │   174 │  31165817 │   79.0 │
│ glotcc   │   113 │  13232715 │   53.9 │
│ finepdfs │    54 │   1218257 │   26.9 │
└──────────┴───────┴───────────┴────────┘

Count one source. A count reads the row counts out of each file's footer rather than the file, so this is a few hundred kilobytes whatever the source weighs.

SELECT count(*) AS documents
FROM read_parquet('hf://datasets/open-index/vitco/data/finepdfs/*.parquet');

┌───────────┐
│ documents │
│   int64   │
├───────────┤
│   1218257 │
└───────────┘

Group by a column. Parquet is columnar, so a query over two columns reads two columns. This one touches 1,218,257 documents across 54 files.

SELECT license_class, count(*) AS documents,
       round(avg(n_syllables)) AS mean_syllables
FROM read_parquet('hf://datasets/open-index/vitco/data/finepdfs/*.parquet')
GROUP BY license_class ORDER BY documents DESC;

┌────────────────────────┬───────────┬────────────────┐
│     license_class      │ documents │ mean_syllables │
│        varchar         │   int64   │     double     │
├────────────────────────┼───────────┼────────────────┤
│ permissive-attribution │   1218257 │         3555.0 │
└────────────────────────┴───────────┴────────────────┘

Look at some documents. Reading text is the one thing here that is not cheap: the row groups hold 50,000 documents each, so the smallest useful read of the text column is a row group of it, which on a full sized part is a couple of hundred megabytes. That is why this one is pointed at a single part, and at the smallest part in the repo, rather than at a glob.

SELECT url, lang, n_syllables, substr(text, 1, 60) AS opening
FROM read_parquet('hf://datasets/open-index/vitco/data/glotcc/glotcc-9ad140b6be3a-00007-00004.parquet')
WHERE lang = 'vie' AND n_syllables BETWEEN 200 AND 400
LIMIT 5;

The lang column is ISO 639-3, so the value to filter on is vie rather than the vi in this card's front matter.

Every column and its type.

DESCRIBE SELECT * FROM read_parquet('hf://datasets/open-index/vitco/data/glotcc/glotcc-9ad140b6be3a-00007-00004.parquet');

Python

The configs in this card's front matter are what datasets reads, so a source is a config name and default is all of them.

from datasets import load_dataset

# One source, streamed rather than downloaded.
ds = load_dataset("open-index/vitco", "finepdfs", split="train", streaming=True)
print(next(iter(ds))["url"])

Streaming is the right default here. The whole repo does not fit on most disks and one source of it does not fit on many, so a run that reads once should read over the network rather than land the corpus first.

When it does need to be on disk, take a source or a single part rather than the repo.

from huggingface_hub import snapshot_download

# One source on disk, which for the smallest of these is 26.9 GB.
snapshot_download(
    "open-index/vitco",
    repo_type="dataset",
    allow_patterns="data/finepdfs/*",
)

import pyarrow.parquet as pq
from huggingface_hub import hf_hub_download

# One part, for looking rather than training. Read the columns you want:
# text is most of the bytes and a row group of it is a couple of hundred MB.
path = hf_hub_download("open-index/vitco", "data/glotcc/glotcc-9ad140b6be3a-00007-00004.parquet", repo_type="dataset")
table = pq.read_table(path, columns=["url", "host", "lang", "n_syllables"])
print(table.num_rows, table.schema.names)

What you can build with it

The reason to keep the provenance columns and skip the filtering is that different people want different corpora out of the same text. These are the ones this repo was shaped for, each with the query that starts it.

Pretraining, and continued pretraining

The whole repo is more Vietnamese than most runs have the budget for, so the first thing a pretraining corpus needs is a filter and a syllable count to spend against. Both are columns, so the count is cheap and the filter does not read the text.

SELECT count(*) AS documents, sum(n_syllables) AS syllables
FROM read_parquet('hf://datasets/open-index/vitco/data/finepdfs/*.parquet')
WHERE lang_score >= 0.9 AND n_syllables >= 200 AND diacritics = 'present';

┌───────────┬────────────┐
│ documents │ syllables  │
│   int64   │   int128   │
├───────────┼────────────┤
│    952841 │ 3826960848 │
└───────────┴────────────┘

Vietnamese is written in syllables and counted here in them, because a syllable count is a property of the text and a token count is a property of somebody's tokenizer. Across the tokenizers we have measured on this corpus a syllable costs between 1.25 and 1.32 tokens, so a syllable budget converts to a token budget by multiplying, and it does not go stale when the tokenizer changes.

For continued pretraining of a model that already speaks some Vietnamese, take one source rather than all of them. The four were built by different projects with different filters, so they fail differently, and a run that only ever sees one of them is a cleaner experiment than a run that sees a blend nobody has characterized.

A corpus for one domain

host is on every row and it is dictionary encoded, so grouping by it across a whole source is a column scan rather than a text read. This is how the legal corpus, the finance corpus and the health corpus come out of a general one.

SELECT host, count(*) AS documents, sum(n_syllables) AS syllables
FROM read_parquet('hf://datasets/open-index/vitco/data/finepdfs/*.parquet')
GROUP BY host ORDER BY documents DESC LIMIT 5;

┌───────────────────────┬───────────┬───────────┐
│         host          │ documents │ syllables │
│        varchar        │   int64   │  int128   │
├───────────────────────┼───────────┼───────────┤
│ static2.vietstock.vn  │     29431 │ 169121447 │
│ static.luatvietnam.vn │     24418 │  93030746 │
│ dmec.moh.gov.vn       │     16702 │   8333159 │
│ cafef1.mediacdn.vn    │     10784 │  31723952 │
│ cldup.com             │      7801 │   1177148 │
└───────────────────────┴───────────┴───────────┘

Two securities sites, the national drug administration and a legal publisher, in the top five of a source that was assembled with none of that in mind. Swap the LIMIT for a WHERE host IN (...) and the domain corpus is a subset of a repo somebody else is already hosting.

A Vietnamese tokenizer

A tokenizer wants a few gigabytes of representative text, not a quarter of a terabyte, and it wants the text to be representative rather than the first rows of the first file. Sample across sources and write the sample out once.

COPY (
  SELECT text
  FROM read_parquet('hf://datasets/open-index/vitco/data/finepdfs/*.parquet')
  WHERE n_syllables BETWEEN 100 AND 2000
  USING SAMPLE 200000 ROWS
) TO 'tokenizer-sample.txt' (FORMAT csv, HEADER false, QUOTE '');

Run it once per source and concatenate, rather than once over a glob of all four, so that the mix is one you chose. The sources are not the same size and sampling the union hands the tokenizer whatever the largest one happens to be.

The documents have newlines in them, so that file has many more lines than it has documents. Feed it to a tokenizer trainer as a stream of text rather than as one document per line, or write Parquet out instead of CSV and keep the row boundaries.

Deduplication and overlap research

This repo is one of the few places the same Vietnamese page exists several times with its provenance intact, because nothing here has been deduplicated. That is a defect in a training corpus and it is the whole dataset for anybody working on dedup, near duplicate detection, or the question of how much four public web corpora actually overlap.

SELECT count(*) AS urls, count(DISTINCT url) AS distinct_urls
FROM read_parquet('hf://datasets/open-index/vitco/data/finepdfs/*.parquet');

┌─────────┬───────────────┐
│  urls   │ distinct_urls │
│  int64  │     int64     │
├─────────┼───────────────┤
│ 1218257 │       1208076 │
└─────────┴───────────────┘

Ten thousand repeats inside a single source, before anybody has compared it to the other three.

Joining two sources on url is the cross corpus version, and it is a column scan of both rather than a text read, which on the two web sources is a few minutes.

SELECT count(*) AS shared_urls FROM
  (SELECT DISTINCT url FROM read_parquet('hf://datasets/open-index/vitco/data/glotcc/*.parquet')) a
  JOIN (SELECT DISTINCT url FROM read_parquet('hf://datasets/open-index/vitco/data/fineweb2/*.parquet')) b
  USING (url);

┌─────────────┐
│ shared_urls │
│    int64    │
├─────────────┤
│     1399167 │
└─────────────┘

That was measured while the repo held 12,858,086 glotcc documents and 20,941,000 fineweb2 ones. Two corpora built by different projects from overlapping crawls, sharing 1.4 million urls out of the 33.8 million documents they had here between them. That is the number a training run pays for if nobody looks, and it is the number a dedup paper wants to explain. Both sources are still growing, so run it again rather than quoting it.

dup_cluster and is_representative are in the schema for the stage that will do this properly, and they are zero in every row here.

Diacritic restoration, and language identification

Vietnamese loses its diacritics constantly, in search boxes, in filenames, in chat, and restoring them is a real task with almost no labeled data published for it. The diacritics column labels every document as present, absent or mixed at ingest, which makes this corpus a training set for that task rather than only a source of text for it.

SELECT diacritics, count(*) AS documents, round(avg(lang_score), 3) AS mean_score
FROM read_parquet('hf://datasets/open-index/vitco/data/finepdfs/*.parquet')
GROUP BY diacritics ORDER BY documents DESC;

┌────────────┬───────────┬────────────┐
│ diacritics │ documents │ mean_score │
│  varchar   │   int64   │   double   │
├────────────┼───────────┼────────────┤
│ present    │   1078990 │      0.995 │
│ mixed      │    108122 │      0.951 │
│ absent     │     31145 │       0.37 │
└────────────┴───────────┴────────────┘

A hundred and eight thousand documents with the tone marks partly stripped and thirty one thousand with them gone, in one source, already paired with the identifier's confidence collapsing from 0.995 to 0.37 as they go. Nobody publishes that pairing on purpose.

lang_score is the upstream identifier's own confidence, kept rather than thresholded, so a language identification experiment can see the documents that a threshold would have removed. That is the set that matters: nobody learns anything from the documents every identifier already agrees on.

Retrieval, embeddings and evaluation sets

Every row has a url and a host next to its text, so a retrieval corpus comes out of this without a separate metadata store, and the host doubles as a weak label for the kind of page it is. For an evaluation set, the same columns are what makes a held out slice defensible: hold out by host rather than by row, and the documents in the training set are not the same pages under a different path.

Contamination checks

If a Vietnamese benchmark is public, some of it is in a web corpus. contam_flags is in the schema for the stage that will mark this and is empty in every row here, so for now the check is a search, which is a text read and is the expensive kind of query. Point it at one part first.

SELECT url, host
FROM read_parquet('hf://datasets/open-index/vitco/data/glotcc/glotcc-9ad140b6be3a-00007-00004.parquet')
WHERE contains(text, 'a sentence from your benchmark');

Rebuilding it yourself

source and source_locator say which file of which upstream corpus each row came out of, down to the row offset, and url says what the page was. Between them a reader can go back to the original corpus and check any document here against it, or skip this repo entirely and take only the list of what is in it. That is deliberate. A corpus nobody can audit is a corpus somebody has to take on trust, and this one is assembled out of other people's work.

One row

A document from glotcc, as SELECT * ... LIMIT 1 returns it. The byte columns are printed as hex here and come back as blobs, and the text is cut because the document is seventeen hundred characters and the point of printing a row is the shape.

{
  "doc_id": "249eac866336b8c059d9d40b0810bb925b7df9640c5f6f6a3d8b57fce13b43ba",
  "raw_id": "28ac80fee008e89826f9eb9884e6a8f914653cf2ebc34a420759270629d5aaac",
  "text": "Tập thể dục giúp nâng cao sức khỏe, cải thiện vóc dáng và giúp hình thành các cơ cho cơ thể dẻo dai hơn. Tuy nhiên không phải ai cũng có nhiều thời gian ...",
  "schema_version": 1,
  "source": "glotcc",
  "source_locator": "v1.0/vie-Latn/vie-Latn_15.parquet:499402",
  "url": "https://www.sanchoi.cc/t/mach-ban-2-cach-chon-dung-cu-tap-the-duc-cuc-chuan/3028",
  "host": "www.sanchoi.cc",
  "url_template": "",
  "fetched_at": "2024-02-24 11:02:49+07",
  "media_type": "text/html",
  "extractor": "gao-gat@1.0.0",
  "pipeline_version": "0.1.0",
  "http_status": 0,
  "robots_decision": "",
  "robots_rule": "",
  "robots_hash": "0000000000000000000000000000000000000000000000000000000000000000",
  "tdm_signals": {},
  "consent": "",
  "lang": "vie",
  "lang_score": 0.98,
  "diacritics": "present",
  "translated": false,
  "gao_qual": 0.0,
  "gao_edu": 0.0,
  "hplt_bucket": 0,
  "register": "",
  "heuristics": {"diacritic_ratio": 0.307, "glotcc_lid_consistency": 1.0, "glotcc_script_share": 1.0},
  "dup_cluster": "00000000000000000000000000000000",
  "dup_cluster_size": 0,
  "is_representative": false,
  "pii_level": 0,
  "pii_types": [],
  "pii_spans": [],
  "license_class": "open",
  "license_evidence": "CC0",
  "structure": "",
  "n_chars": 1737,
  "n_syllables": 389,
  "n_tokens": 0,
  "contam_flags": [],
  "upstream_fields": {"glotcc_sentences": "10", "glotcc_tlsh": "tlsh:T1EE572C41BC88D8...", "warc_record_id": "<urn:uuid:1216df49-7788-42c0-9aa4-7bbf0b516a1b>"}
}

gao_qual, gao_edu, n_tokens and pii_level are zero because the stages that fill them have not run on this repo. They are in the schema so that a query written here still runs against a release, where they are filled. register and hplt_bucket are the source corpus's own labels rather than gao's, filled where the corpus published them and empty where it did not.

The columns

42 columns, in file order. Every part in this repo has all of them, and a column a stage has not run yet is null rather than absent, so a query written against one source works against the next.

column	type	filled in by	meaning
doc_id	bytes(32)	normalize	blake3 of the normalized text, which is the document's identity: two documents with the same normalized text are the same document whichever path found them
raw_id	bytes(32)	harvest	blake3 of the bytes before extraction, which is what links this row back to the WARC record or the source file it came out of
text	string	normalize	the document text, normalized to NFC with canonical tone mark placement and legacy encodings already transcoded
schema_version	uint16	store	the version of this layout, carried per row because a store appended to across a pipeline upgrade holds two versions at once and a reader has to be able to tell
source	string	harvest	which acquisition path produced the document, one of the six gao runs
source_locator	string	harvest	where in that source it came from: shard and offset for an ingested corpus, file, offset and length for a WARC record
url	string	harvest	the page it came from, canonicalized
host	string	harvest	the host of that URL, which is the unit politeness, budgets and takedowns are all measured in
url_template	string	harvest	the URL with its variable path and query parts replaced by placeholders, which is what the crawl budgets against and how a calendar trap reads as one URL rather than ten thousand
fetched_at	timestamp(millisecond)	harvest	when the document was fetched, in UTC milliseconds
media_type	string	harvest	the media type the response declared, before extraction decided what to do with it
extractor	string	harvest	name and semver of the extractor, because two documents extracted by different versions of the same extractor are not comparable
pipeline_version	string	store	semver of the cleaning pipeline that produced this row
http_status	uint16	harvest	the status the fetch got, empty for a document that arrived through somebody else's corpus rather than through our crawl
robots_decision	string	harvest	what robots.txt said about this fetch, recorded per fetch rather than assumed from a global setting so that a consent question years later has an answer
robots_rule	string	harvest	the rule that decided it, in the spelling the site wrote
robots_hash	bytes(32)	harvest	blake3 of the robots.txt the decision was made against, so the decision can be rechecked against the file rather than against the file as it is today
tdm_signals	map<string, string>	harvest	the machine readable text and data mining reservations the response carried, keyed by mechanism and holding what that mechanism said
consent	string	harvest	what the page said about being kept and trained on, in one word, where empty means nobody asked rather than the page said yes
lang	string	sift	the language identifier's verdict, which is vie for everything in gao and is stored anyway because a column that is constant today needs no migration tomorrow
lang_score	float32	sift	how sure the identifier was
diacritics	string	sift	present, absent or mixed, because Vietnamese written without tone marks is still Vietnamese and is still not the same distribution
translated	bool	sift	the machine translation detector's verdict, since translated Vietnamese reads as fluent to a metric and as wrong to a native speaker
gao_qual	float32	sift	the quality classifier's score for this document
gao_edu	float32	sift	the educational value score, which is what the gao-edu slice is selected on
hplt_bucket	uint8	harvest	the source corpus's own quality bucket where it had one, kept so gao's classifier can be compared against an independent one rather than only against itself
register	string	harvest	the source corpus's own register label, kept for the same reason
heuristics	map<string, float32>	sift	the raw heuristic measurements rather than the verdicts, so the corpus can be refiltered at a different threshold without being recomputed from the text
dup_cluster	bytes(16)	mill	which duplicate cluster the document belongs to, empty when it is in none
dup_cluster_size	uint32	mill	how large that cluster is
is_representative	bool	mill	marks the one document per cluster a deduplicated view keeps, with the rest left in the store because deduplication is tuned rather than maximized
pii_level	uint8	cover	how much personal data has been removed: none, the structured identifiers, or those plus addresses and identifying names
pii_types	list<string>	cover	which kinds of personal data were found
pii_spans	list<span>	cover	where they were found, empty on every row the cleaning line writes, because the offsets index the text before it was covered and because offsets published next to covered text say where the identifiers were
license_class	string	law	the per document redistribution determination, stored by name so a file read without gao says restricted rather than 3
license_evidence	string	law	what determined that class, since a class without evidence is a guess
structure	string	harvest	what the document is: article, forum thread, legal, thesis, gazette, transcript, which drives both the extraction handler and the mixture weights
n_chars	uint32	normalize	how many characters the text holds
n_syllables	uint32	normalize	how many Vietnamese syllables it holds, which is the unit that survives a change of tokenizer
n_tokens	uint32	count	how many gao tokens it holds, under the tokenizer named in the manifest
contam_flags	list<string>	pick	which evaluation benchmarks this document overlaps, flagged rather than deleted so one store can serve a training run that excludes them and an analysis that counts them
upstream_fields	map<string, string>	harvest	the source corpus's own metadata, verbatim, which is the difference between answering a provenance question later and having to ingest again

pii_spans is a list of structs, and the struct is:

field	type	meaning
start	uint32	byte offset into the text where the identifier begins
len	uint32	how many bytes long it is, counted in bytes rather than runes because a reader slicing the text has bytes
type	string	which kind of identifier it is, from the same set pii_types draws on

The full schema, including the Parquet spelling of each type and what the dictionary encoded columns cost, is at https://github.com/tamnd/gao/blob/main/SCHEMA.md.

What this repo is

What a stage wrote on its way to a release, published as it is written so that a box can push a part and delete it rather than holding what it has finished. It is public like everything else here, it is rewritten when a source is pinned again, and it is not covered by a signed manifest. A release is, and that is the difference worth knowing before anybody builds on this.

What ships and what does not

This repo carries document text, so it carries only documents whose text may be redistributed.

license class	text	metadata
open	yes	yes
permissive-attribution	yes	yes

Every row carries its own class in the license_class column, so a reader who needs a narrower set than this repo holds can filter for it rather than trust the repo name.

A page that reserved its text and data mining rights is not here, whatever its license says. The two are separate questions and the reservation is honored at the write, so a page that said no cannot reach a published file through a stage that forgot to ask. The consent column records what each page said, and an empty value means nobody was there to ask, which is true of every document that came out of somebody else's corpus.

Things to know before you use it

It is web text, so it is what the web is. The four sources are Common Crawl and Internet Archive derivatives plus a set of PDFs. Vietnamese on the open web skews towards commerce, SEO, news aggregation and forums, and away from anything behind a login or inside an app. Gambling and affiliate marketing sites are well represented, because they are well represented on the web and no filter here removed them. A model trained on this without filtering will write like that.

It is not deduplicated. Not within a source and not across sources. A page that all four corpora crawled is four documents here, and popular pages are duplicated inside a single source as well. This is on purpose and it is not a state you want to train on. Deduplicate before you do.

It is not quality filtered. gao_qual and gao_edu are zero in every row, boilerplate has not been stripped beyond what each upstream corpus did, and no classifier has been run. What the upstream projects removed is removed, and they do not agree about what that is.

The language identification is inherited. lang and lang_score come from whichever identifier the source used, and the sources used different ones. Documents that are mostly Vietnamese with English or Chinese passages in them are in here labeled Vietnamese, and so are some that are not Vietnamese at all.

Personal information has not been removed. pii_level, pii_types and pii_spans are in the schema and are empty, because the stage that fills them has not run on this repo. Names, phone numbers, addresses and email addresses that were on a public page are in the text as they were on the page. If that matters for what you are building, filter before you train rather than after.

There is no split and no order. The parts are the order the ingest happened to read the input files in. Nothing is shuffled, and consecutive rows in a part are frequently from the same site, so a reader taking the first N rows is taking a sample of one crawl of a handful of hosts rather than a sample of the corpus.

The sources are not balanced and were never meant to be. hplt3 is 72% of the documents here on its own. If a run should see the sources evenly, sample them evenly, because reading the repo does not.

What this is not

This is not a release. There is no signed manifest behind it, no merkle root over the files, and no promise that a part will still be there next week under the same name. A run pushes each part as it closes it and deletes the local copy, which is what lets a box with a terabyte of disk work through corpora that do not fit on it, and it means the file list is whatever the last run got through rather than a set anybody has fixed.

What that changes for a reader:

• Read it to see what the pipeline produces, and to build on the raw text under one schema without pulling four corpora in four formats.
• Do not cite a document count off it in anything that has to still be true later. Cite a release.
• Re-pinning a source rewrites its parts under a new revision in the same directory, so a query that has to be stable should name a revision rather than a source.
• Nothing here has been deduplicated against anything else here. The same page can be in three of these corpora and it is three documents in this repo.

The releases carry the signed manifest, the dedup, and the quality filtering. They are the other repos in open-index.

Citation

If you use this, cite the corpora it is made of. They did the collecting. This repo did the reading.

• HPLT v3, https://hplt-project.org/datasets/v3.0
• fineweb-2, https://huggingface.co/datasets/HuggingFaceFW/fineweb-2
• GlotCC v1, https://huggingface.co/datasets/cis-lmu/GlotCC-V1
• FinePDFs, https://huggingface.co/datasets/HuggingFaceFW/finepdfs

For the assembly itself:

@misc{vitco,
  title        = {ViTco: Vietnamese corpora under one schema},
  author       = {The gao project},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/open-index/vitco}},
  note         = {Built with gao, https://github.com/tamnd/gao}
}

Where this comes from

The pipeline that built it, the ingest contract every document had to pass, and the reasoning behind both are at https://github.com/tamnd/gao.

This card is generated by gao store card, from the snapshot manifest where there is one and from parts.csv where there is not. Editing it by hand works until the next run overwrites it.