open-index/vitco-clean

ViTco Clean

2,279,914 Vietnamese documents from 2 public corpora, 10.6 GB of Parquet, one schema

This dataset is the same corpora after the cleaning line: normalized, measured, filtered to Vietnamese prose, deduplicated on identity, and with the personal identifiers covered.

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

open-index/vitco is four public Vietnamese corpora read once and put under one schema, with nothing taken out. This is that corpus after the cleaning line, which is the work somebody starting from the raw repo would otherwise have to write first.

Four things were done to every document here, in this order, and the order is the design. The text was normalized, because every stage after it compares strings and two spellings of one word are two documents to a hash. It was measured and sifted, because there is no point scoring a page that is not Vietnamese prose. It was deduplicated on the normalized text, because the corpus is four projects reading overlapping crawls and that is the largest single fact about it. Then the personal identifiers were covered, last of the four that change the text, so that what gets covered is covered in the document that actually ships.

How much that removes was measured by joining every part in this repo back to the part of the same name in the raw repo. It is not one number, and the spread is the useful part:

source	parts read	documents in	documents out	kept
hplt3	7	1,839,058	1,067,860	58.1%
finepdfs	35	796,802	269,592	33.8%
	42	2,635,860	1,337,452	50.7%

The keep rate is a property of the source before it is a property of the line, and the run report says which property. Over the 7 FinePDFs parts the line last reported on, 154,138 documents went in and 51,899 came out, and the largest single reason for the rest was repetition, at 65,875 documents against 19,136 for boilerplate, 10,182 for not being Vietnamese and 6,720 for being too short. That is what text pulled out of PDFs looks like: page headers and footers and table rows running down the document. HPLT v3 arrives already sorted by a quality model of its own and loses less. The line is the same code over both.

These are readings over the 42 parts named in the table rather than the corpus's rate, and the runs since have added more. Nothing here was tuned to hit a keep rate, and the breakdown of what went for which reason is in the run report rather than on this card.

What was not done is the quality classifier, and it is missing rather than stubbed. gao_qual and gao_edu are 0.0 in every row because the model behind them is trained against a hand built reference set that does not exist yet, and a filter with an untrained model behind it removes documents for a reason nobody could defend. So this repo is Vietnamese prose. Finding good Vietnamese prose is a later stage, and saying so here is cheaper than letting somebody discover it from the data.

Everything the sift measured is on the row and none of it is a verdict. lang_score, n_syllables, diacritics and the heuristics map are gao's own measurements here rather than each upstream project's, taken with one identifier over all sources, so a corpus filtered at one threshold can be refiltered at another without going back to the text.

What is in it

source	documents	parts	input files	size	pinned at
hplt3	1,901,519	11	2	2.5 GB	hplt3-5b2785d5b11c
finepdfs	378,395	50	3	8.1 GB	finepdfs-220bac3acbf0
total	2,279,914	61		10.6 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.

1,901,519 documents here, 2.5 GB of Parquet, pinned at hplt3-5b2785d5b11c. Upstream: https://hplt-project.org/datasets/v3.0

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.

378,395 documents here, 8.1 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 10 more
data/finepdfs/
  finepdfs-220bac3acbf0-00000-00000.parquet
  ... and 49 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-clean/parts.csv'
GROUP BY source ORDER BY documents DESC;

┌──────────┬───────┬───────────┬────────┐
│  source  │ parts │ documents │   gb   │
│ varchar  │ int64 │  int128   │ double │
├──────────┼───────┼───────────┼────────┤
│ hplt3    │    11 │   1901519 │    2.5 │
│ finepdfs │    50 │    378395 │    8.1 │
└──────────┴───────┴───────────┴────────┘

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-clean/data/finepdfs/*.parquet');

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

Group by a column. Parquet is columnar, so a query over two columns reads two columns. This one touches 378,395 documents across 50 files.

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

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-clean/data/finepdfs/finepdfs-220bac3acbf0-00002-00017.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-clean/data/finepdfs/finepdfs-220bac3acbf0-00002-00017.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-clean", "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 8.1 GB.
snapshot_download(
    "open-index/vitco-clean",
    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-clean", "data/finepdfs/finepdfs-220bac3acbf0-00002-00017.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 every provenance column through the cleaning line is that different people want different corpora out of the same text, and a repo that filtered the text and then dropped the columns to filter it further with would have made everybody's remaining decisions for them. 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-clean/data/finepdfs/*.parquet')
WHERE lang_score >= 0.9 AND n_syllables >= 200 AND diacritics = 'present';

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-clean/data/finepdfs/*.parquet')
GROUP BY host ORDER BY documents DESC LIMIT 5;

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-clean/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.

What the deduplication did, and what it left

Every document here was compared against the ones its own run had already admitted, on dup_cluster, which is a hash of the text with everything a republisher changes taken out of it: the case, the punctuation, the i and y pair, and the spacing. The copy that arrived first was kept and the rest were dropped, so is_representative is true on every row in this repo and the dropped copies are counted in the run report.

What that does not cover is the copies that were never in the same run. Sources are cleaned on different boxes and finish at different times, so a page that two sources both carry is deduplicated only if one run saw both. dup_cluster is published for exactly that reason. The global pass is a group by over this repo rather than a second read of the text.

SELECT dup_cluster, count(*) AS copies, count(DISTINCT source) AS sources
FROM read_parquet('hf://datasets/open-index/vitco-clean/data/*/*.parquet')
GROUP BY dup_cluster HAVING copies > 1 ORDER BY copies DESC;

Run against hplt3 and finepdfs while the repo held 1,011,947 documents of the two, that came back with a single shared cluster, which is what two corpora built from web crawls and from PDFs respectively should look like. The number worth rerunning it for is the one it gives once fineweb2 and glotcc are in here beside them, since those two are built from overlapping Common Crawl snapshots and shared 1.4 million urls in the raw repo.

dup_cluster_size is zero in every row and it is a zero rather than a one on purpose. A streaming pass sees a document before it has seen the copies of it, so it can say this is the first copy and it cannot say how many copies there turned out to be, and a one written there would be a lie that survives into everybody's downstream count.

Note that identical text is not the same question as a repeated url. The pass compares text, so a page crawled twice at different times with different content is two documents here under one url, which is correct and is worth knowing before anybody uses url as a key.

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

At 1,011,947 documents that was 1,003,042 distinct urls, so a little under nine thousand urls carry more than one document that is not a copy of the others.

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, measured after normalization rather than before it, so a page whose marks are there but decomposed is labeled present rather than counted as a page that lost them. That makes this corpus a training set for the 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-clean/data/finepdfs/*.parquet')
GROUP BY diacritics ORDER BY documents DESC;

lang_score here is gao's own measurement rather than the upstream project's: the share of tokens that are Vietnamese syllables, taken with one identifier over every source, which is what makes it comparable between them. It is recorded and not thresholded away, so the documents sitting near whatever bar a piece of work would have set are still in the repo to be looked at. A document typed without its tone marks is judged on a separate and looser bar, which is why diacritics = 'absent' rows are here at all, and it is also why their scores read low against rows that kept their marks.

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-clean/data/finepdfs/finepdfs-220bac3acbf0-00002-00017.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 hplt3, 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 forty eight hundred characters and the point of printing a row is the shape.

{
  "doc_id": "17612751ef1ed88b1b862e4cdd02d6f7984edc6ae8fe9b16ef7c9e138276e051",
  "raw_id": "3a51c47208fe6dea1f6de5915c157227ae6c47fc379bcd01b2229599bc41964b",
  "text": "Du lịch bụi azerbaijan – vùng đất của lửa và gió\nAzerbaijan – vùng đất của lửa và gió\nCơ hội được đến với Azerbaijan của tôi thật tình cờ, khi biết Chính phủ Azerbaijan tổ chức một cuộc thi âm nhạc ...",
  "schema_version": 1,
  "source": "hplt3",
  "source_locator": "vie_Latn/10_1.jsonl.zst:47334",
  "url": "https://dongphucplus.com/du-lich-bui-azerbaijan-vung-dat-cua-lua-va-gio.html",
  "host": "dongphucplus.com",
  "url_template": "",
  "fetched_at": "2020-04-08 15:31:12+07",
  "media_type": "text/html",
  "extractor": "gao-gat@1.0.0",
  "pipeline_version": "1.0.0",
  "http_status": 0,
  "robots_decision": "",
  "robots_rule": "",
  "robots_hash": "0000000000000000000000000000000000000000000000000000000000000000",
  "tdm_signals": {},
  "consent": "",
  "lang": "vie",
  "lang_score": 0.935,
  "diacritics": "present",
  "translated": false,
  "gao_qual": 0.0,
  "gao_edu": 0.0,
  "hplt_bucket": 10,
  "register": "NA",
  "heuristics": {"alpha_rate": 0.971, "bare_rate": 0.935, "bullet_rate": 0.0, "diacritic_rate": 0.823, "dup_line_rate": 0.0, "dup_line_runes": 0.0, "ellipsis_rate": 0.0, "mark_rate": 0.823, "mean_syllable": 3.697, "repeat_gram_max": 0.0, "stop_words": 28.0, "syllable_rate": 0.935, "syllables": 974.0, "symbol_rate": 0.0, "top_gram_max": 0.016},
  "dup_cluster": "29e8b0f872159619dd0f8608340e5900",
  "dup_cluster_size": 0,
  "is_representative": true,
  "pii_level": 1,
  "pii_types": ["phone", "tax", "name"],
  "pii_spans": [],
  "license_class": "open",
  "license_evidence": "CC0 on the release, and the release is what gao ingests",
  "structure": "",
  "n_chars": 4794,
  "n_syllables": 997,
  "n_tokens": 0,
  "contam_flags": [],
  "upstream_fields": {"crawl_id": "CC-MAIN-2020-16", "hplt_filter": "keep", "hplt_id": "cac067bd2354be4f655476277f2d024b", "source_encoding": "utf-8", "warc_file": "./segments/1585371810807.81/warc/CC-MAIN-20200408072713-20200408103213-00428.warc.gz", "warc_offset": "434875215"}
}

The row above is what the four stages leave behind. pii_level is 1 and pii_types names three kinds, so cover found a phone number, a tax code and a name and replaced each of them in the text. The covering is in the text rather than in a separate column, and further down the same document it reads:

CÔNG TY TNHH DỊCH VỤ DU LỊCH ANH TUẤN Giấy phép kinh doanh số: [MST] Ngày cấp: 01/08/1993

dup_cluster is filled and is_representative is true, which together say this document survived the deduplication as the copy the run kept. dup_cluster_size is zero for the reason given above: the run counts nothing, it keeps the first and drops the rest.

gao_qual, gao_edu and n_tokens are zero because the stages that fill them have not run on this repo. register and hplt_bucket are not gao's: they are the upstream corpus's own labels, carried through the line unchanged, 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 still web text, and the cleaning line does not change what the web is. The 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. The sift removed the pages that are not prose, which takes out a good deal of the navigation and the price tables, and it has no opinion at all about a fluent, well formed affiliate marketing article. Those are still here, because they are still Vietnamese prose.

The deduplication is exact and it is per run. Two documents are the same only if their text matches once the case, the punctuation and the spacing are taken out, so a page rewritten by a republisher is two documents and near duplicate detection has not been run at all. And the comparison is against what one run had seen, not against the corpus, so copies that arrived in different runs are both here. dup_cluster is on every row so that both of those are a query rather than a re-read.

It is not quality filtered. gao_qual and gao_edu are 0.0 in every row. The sift decided whether a document is Vietnamese prose and nothing here decided whether it is good Vietnamese prose, because the classifier that would is trained against a reference set that does not exist yet. If the corpus you need is the educational or the high quality slice, this is the input to that stage rather than the output of it.

The language identification is gao's, not the upstream project's. lang_score here is the share of tokens that are Vietnamese syllables, measured by one identifier over every source, which is the point: the raw repo carries four projects' four identifiers and their scores are not comparable to each other. It is a syllable inventory rather than a neural model, so a document with long English or Chinese passages inside Vietnamese prose passes, and a document written without tone marks is judged on a separate and looser bar. Both of those are deliberate and both are visible in lang_score and diacritics rather than hidden behind a threshold.

Personal information is covered, not removed. Email addresses, phone numbers, addresses, national ID numbers, tax codes and plate numbers were found and replaced in the text at level L1, and pii_types says which kinds each document held. About three documents in ten carry at least one. What that is not is a guarantee: it is a pattern matcher over Vietnamese formats, it will miss things written unusually, and a name in a sentence is only caught where the sentence marks it as one. pii_spans is deliberately empty, because the offsets it would carry point into the text before the covering and would amount to a published index of where the identifiers were.

There is no split and no order. The parts are the order the ingest happened to read the input files in, and the cleaning line preserved it. 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 83% 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 train on, which is what the cleaning line is for, and read the raw repo instead if what you want is to make the filtering decisions yourself.
• 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.
• The deduplication here is per run rather than over the corpus, so a global pass is still owed. It is a group by on dup_cluster rather than a re-read, which is why that column is published.

The releases carry the signed manifest, the global 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
• FinePDFs, https://huggingface.co/datasets/HuggingFaceFW/finepdfs

For the assembly itself:

@misc{vitco-clean,
  title        = {ViTco Clean: Vietnamese corpora under one schema},
  author       = {The gao project},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/open-index/vitco-clean}},
  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.