| """Build a random, prompt-ready sample from the bagaco3 dataset.""" |
|
|
| import json |
| import os |
| import random |
| import urllib.request |
| from concurrent.futures import ThreadPoolExecutor, as_completed |
| from types import SimpleNamespace |
|
|
| import polars as polars |
| from tqdm import tqdm |
|
|
| config = SimpleNamespace( |
| dataset="duarteocarmo/bagaco3", |
| text_column="text", |
| truncate_chars=1500, |
| n_shards=300, |
| rows_per_shard=100, |
| max_workers=12, |
| output_file="to_annotate_30K.jsonl", |
| seed=42, |
| ) |
|
|
| PROMPT: str = """ |
| Below is an extract from a web page. Evaluate whether the page has a high educational value |
| and could be useful in an educational setting for teaching from primary school to grade school |
| levels using the additive 5-point scoring system described below. The text will be in Portuguese. |
| Evaluate its educational value based on content quality, not language. |
| |
| - 1 point: basic information relevant to educational topics, even with ads/promotional material. |
| - 2 points: addresses elements pertinent to education but doesn't align closely with standards. |
| - 3 points: appropriate for educational use, introduces key concepts relevant to school curricula. |
| - 4 points: highly relevant for grade school education, clear writing, substantial content. |
| - 5 points: outstanding educational value, perfectly suited for primary/grade school teaching. |
| |
| The extract: |
| <extract> |
| {} |
| </extract> |
| |
| After examining the extract, briefly justify your total score (up to 100 words) |
| and provide the educational score (0-5). Also classify the extract into one category: Society, |
| Arts, Business, Science, Sports, Lifestyle, Health, Games, or News. |
| |
| Respond ONLY with a JSON object in this format: |
| {{"justification": "up to 100 words", "educational_score": 0, "category": "category"}} |
| |
| Examples of good responses: |
| {{"justification": "The extract clearly explains photosynthesis and its role in plant growth, with useful scientific concepts for students.", "educational_score": 4, "category": "Science"}} |
| {{"justification": "The extract is mainly a product listing and offers little explanation beyond basic promotional information.", "educational_score": 1, "category": "Lifestyle"}} |
| """.strip() |
|
|
|
|
| def shard_urls(token: str | None) -> list[str]: |
| """Return dataset parquet shard URLs.""" |
| api_url = f"https://huggingface.co/api/datasets/{config.dataset}" |
| headers = {"Authorization": f"Bearer {token}"} if token else {} |
| request = urllib.request.Request(url=api_url, headers=headers) |
| with urllib.request.urlopen(request) as response: |
| filenames = [shard["rfilename"] for shard in json.load(response)["siblings"]] |
| return [ |
| f"hf://datasets/{config.dataset}/{filename}" |
| for filename in filenames |
| if filename.endswith(".parquet") |
| ] |
|
|
|
|
| def fetch_window( |
| url: str, seed: int, storage_options: dict[str, str] | None |
| ) -> polars.DataFrame: |
| """Fetch one random, truncated shard window.""" |
| scan = polars.scan_parquet(source=url, storage_options=storage_options) |
| rows = scan.select(polars.len()).collect().item() |
| rng = random.Random(x=seed) |
| offset = rng.randint(0, max(rows - config.rows_per_shard, 0)) |
| return ( |
| scan.slice(offset=offset, length=config.rows_per_shard) |
| .select( |
| polars.col(config.text_column) |
| .str.slice(offset=0, length=config.truncate_chars) |
| .alias("text_concat"), |
| polars.col("source"), |
| ) |
| .with_columns( |
| polars.format(PROMPT, polars.col("text_concat")).alias("prompt") |
| ) |
| .collect() |
| ) |
|
|
|
|
| def fetch_windows( |
| urls: list[str], seeds: list[int], storage_options: dict[str, str] | None |
| ) -> list[polars.DataFrame]: |
| """Fetch shard windows concurrently.""" |
| windows: list[polars.DataFrame | None] = [None] * len(urls) |
| with ThreadPoolExecutor(max_workers=config.max_workers) as executor: |
| futures = { |
| executor.submit( |
| fetch_window, |
| url=url, |
| seed=seed, |
| storage_options=storage_options, |
| ): index |
| for index, (url, seed) in enumerate(zip(urls, seeds, strict=True)) |
| } |
| for future in tqdm( |
| as_completed(futures), total=len(futures), desc="Fetching shard windows" |
| ): |
| windows[futures[future]] = future.result() |
|
|
| return [window for window in windows if window is not None] |
|
|
|
|
| def main() -> None: |
| """Save the sampled rows as NDJSON.""" |
| token = os.getenv("HF_TOKEN") |
| storage_options = {"token": token} if token else None |
| rng = random.Random(x=config.seed) |
| urls = rng.sample(population=shard_urls(token=token), k=config.n_shards) |
| seeds = [rng.getrandbits(64) for _ in urls] |
| samples = polars.concat( |
| items=fetch_windows(urls=urls, seeds=seeds, storage_options=storage_options) |
| ) |
| expected_rows = config.n_shards * config.rows_per_shard |
| if samples.height != expected_rows: |
| raise RuntimeError(f"Expected {expected_rows} rows, got {samples.height}") |
|
|
| print(samples["source"].value_counts(sort=True)) |
| samples.write_ndjson(file=config.output_file) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
