| """Shared schemas and bounded-memory Parquet writing for dataset releases.""" |
|
|
| import hashlib |
| import json |
| import logging |
| from pathlib import Path |
| import time |
|
|
| import pyarrow as pa |
| import pyarrow.parquet as pq |
|
|
|
|
| LOG = logging.getLogger(__name__) |
| RELEASE_FORMAT_VERSION = 2 |
| |
| LEGACY_SCORE_COLUMNS = { |
| "negative_mining_scores": "negative_retrieval_scores", |
| "skipped_mining_scores": "skipped_retrieval_scores", |
| "mining_score": "retrieval_score", |
| } |
|
|
|
|
| def retrieval_score_schema(schema): |
| names = [LEGACY_SCORE_COLUMNS.get(name, name) for name in schema.names] |
| if len(names) != len(set(names)): |
| raise ValueError("Both legacy and retrieval score columns are present") |
| return pa.schema([field.with_name(name) for field, name in zip(schema, names)], metadata=schema.metadata) |
|
|
|
|
| GENERATION_ORIGIN = pa.struct([ |
| ("source_query_id", pa.string()), |
| ("query_type", pa.string()), |
| ("difficulty", pa.string()), |
| ("character", pa.string()), |
| ("query_length_target", pa.int64()), |
| ("metadata_json", pa.string()), |
| ]) |
| OTHER_QUERY = pa.struct([ |
| ("query_id", pa.int64()), |
| ("mining_query_id", pa.int64()), |
| ("query", pa.string()), |
| ("query_word_count", pa.int64()), |
| ("generation_metadata", pa.list_(GENERATION_ORIGIN)), |
| ]) |
| TRAIN_SCHEMA = pa.schema([ |
| ("query_id", pa.int64()), |
| ("mining_query_id", pa.int64()), |
| ("query", pa.string()), |
| ("query_word_count", pa.int64()), |
| ("generation_metadata", pa.list_(GENERATION_ORIGIN)), |
| ("other_queries", pa.list_(OTHER_QUERY)), |
| ("positive_idx", pa.int64()), |
| ("negative_idxs", pa.list_(pa.int64())), |
| ("negative_retrieval_scores", pa.list_(pa.float64())), |
| ("negative_reranker_scores", pa.list_(pa.float64())), |
| ("negative_reranker_raw_scores", pa.list_(pa.float64())), |
| ("positive_reranker_score", pa.float64()), |
| ("positive_reranker_raw_score", pa.float64()), |
| ("skipped_idxs", pa.list_(pa.int64())), |
| ("skipped_retrieval_scores", pa.list_(pa.float64())), |
| ]) |
| REF_SCHEMA = pa.schema([ |
| ("finepdf_idx", pa.int64()), ("finepdf_id", pa.string()), |
| ("source_shard", pa.string()), ("row_in_shard", pa.int64()), |
| ]) |
| NEGATIVE_ALIAS_SCHEMA = pa.schema([ |
| ("query_id", pa.int64()), ("mining_query_id", pa.int64()), |
| ("positive_mining_id", pa.int64()), ("positive_idx", pa.int64()), |
| ("removed_mining_id", pa.int64()), ("canonical_idx", pa.int64()), |
| ("retained_mining_id", pa.int64()), ("reason", pa.string()), |
| ("retrieval_score", pa.float64()), ("reranker_score", pa.float64()), |
| ("reranker_raw_score", pa.float64()), |
| ]) |
|
|
|
|
| def write_json(path, value): |
| Path(path).write_text(json.dumps(value, indent=2, sort_keys=True) + "\n") |
| LOG.info("Wrote %s", path) |
|
|
|
|
| def sha256(path): |
| digest = hashlib.sha256() |
| with Path(path).open("rb") as stream: |
| for chunk in iter(lambda: stream.read(1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| class ShardedWriter: |
| """Write fixed-size shards without buffering an entire output shard.""" |
|
|
| def __init__(self, root, config, schema, rows_per_shard=100_000): |
| self.root = Path(root) |
| self.config = config |
| self.directory = self.root / config |
| self.directory.mkdir(parents=True) |
| self.schema = schema |
| self.capacity = rows_per_shard |
| self.writer = None |
| self.in_shard = 0 |
| self.rows = 0 |
| self.shards = [] |
| self.started = time.monotonic() |
| self.last_report = self.started |
|
|
| def write(self, table): |
| table = table.cast(self.schema) |
| offset = 0 |
| while offset < table.num_rows: |
| if self.writer is None: |
| self.path = self.directory / "part-{:05d}.parquet".format(len(self.shards)) |
| self.writer = pq.ParquetWriter(self.path, self.schema, compression="zstd") |
| LOG.info("Opening output shard: %s", self.path) |
| count = min(self.capacity - self.in_shard, table.num_rows - offset) |
| self.writer.write_table(table.slice(offset, count), row_group_size=8192) |
| self.rows += count |
| self.in_shard += count |
| offset += count |
| if self.in_shard == self.capacity: |
| self._close_shard() |
| now = time.monotonic() |
| if now - self.last_report >= 60: |
| LOG.info("Writing %s: %s rows, %d completed shards, %.1f min elapsed", |
| self.config, format(self.rows, ",d"), len(self.shards), (now - self.started) / 60) |
| self.last_report = now |
|
|
| def _close_shard(self): |
| if self.writer is not None: |
| self.writer.close() |
| LOG.info("Closed %s (%s rows); computing SHA256", self.path, format(self.in_shard, ",d")) |
| self.shards.append({ |
| "path": self.path.relative_to(self.root).as_posix(), |
| "start_row": self.rows - self.in_shard, |
| "num_rows": self.in_shard, |
| "sha256": sha256(self.path), |
| }) |
| LOG.info("Output shard ready: %s (%.1f MiB; %s total %s rows)", self.path, |
| self.path.stat().st_size / (1024 * 1024), format(self.rows, ",d"), self.config) |
| self.writer = None |
| self.in_shard = 0 |
|
|
| def close(self): |
| self._close_shard() |
| LOG.info("Finished %s: %s rows in %d shards (%.1f s)", self.config, |
| format(self.rows, ",d"), len(self.shards), time.monotonic() - self.started) |
| return {"num_rows": self.rows, "shards": self.shards} |
|
|
