new QuEsT

LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) [2024] [Alex Steve Chung Alvarez]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,3 +1,79 @@
----
-license: mit
----
+---
+license: mit
+---
+
+# Dataset Card for QuEsT
+
+<!-- Provide a quick summary of the dataset. -->
+
+The Quechua Spanish Translations dataset (QuEsT) is a language pair dataset of quechua sentences and its translations to spanish.
+
+## Dataset Details
+
+### Dataset Description
+
+<!-- Provide a longer summary of what this dataset is. -->
+The QuEsT Dataset is conformed of two subsets: train and test. In this section we are going to refer as dataset to the train subset only.
+
+The dataset consists of pairs of audios and their transcriptions in the languages of Quechua Cuzco (quz) and Spanish (spa), each pair being conformed by the translation of the sentences from one language to the other.
+
+We were able to collect about 42 minutes of Quechua and 34 minutes of Spanish from 6 speakers, being 2 men and 4 women.
+Around 49 minutes (64% of the audio) were recorded from women, while around 27, (36%) from men.
+
+
+- **Curated by:** Alex Steve Chung Alvarez
+- **Funded by:** Vicerrectorate of Research from National University of Engineering, Lima - Peru
+- **Shared by:** Alex Steve Chung Alvarez
+- **Language(s) (NLP):** quechua, spanish
+- **License:** MIT
+
+
+## Uses
+
+<!-- Address questions around how the dataset is intended to be used. -->
+
+### Direct Use
+
+<!-- This section describes suitable use cases for the dataset. -->
+
+The aim of this dataset is to train text-to-speech models and machine translation models with quechua and/or spanish languages.
+
+## Dataset Structure
+
+<!-- This section provides a description of the dataset fields, and additional information about the dataset structure such as criteria used to create the splits, relationships between data points, etc. -->
+
+### Quest
+ - train
+   - speaker_name
+     - transcripts.txt
+     - language id (qu, es)
+       - *audio_files.wav
+ - test
+   - languag id (qu, es)
+     - *audio_files.wav
+
+## Dataset Creation
+
+### Source Data
+
+<!-- This section describes the source data (e.g. news text and headlines, social media posts, translated sentences, ...). -->
+
+Crowdsourced data of quechua speakers from Cusco.
+
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the dataset, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+
+## Dataset Card Authors [optional]
+
+Alex Steve Chung Alvarez
+
+## Dataset Card Contact
+
+schunga@uni.pe

build_parquet.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+# Robust build_parquet.py
+# Usage examples:
+#   python build_parquet.py
+#   python build_parquet.py --root . --splits train test
+#   python build_parquet.py --root /abs/path/to/repo
+# Requirements: datasets==3.*, pyarrow==17.*, soundfile==0.12.*
+
+import argparse, csv, re, sys, zipfile
+from pathlib import Path
+from datasets import Dataset, Audio
+
+AUDIO_EXTS = {".wav", ".flac", ".mp3", ".ogg", ".m4a"}
+ALLOW_MISSING_TEXT_SPLITS = {"test"}
+PATTERNS = [
+    re.compile(r"nombre_(qu|es)_(\d+)$", re.IGNORECASE),
+    re.compile(r"(?:.*_)?(qu|es)_(\d+)$", re.IGNORECASE),
+    re.compile(r"(\d+)_(qu|es)$", re.IGNORECASE),
+]
+
+def parse_args():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--root", type=Path, default=Path.cwd(), help="Repo root where transcripts.txt lives")
+    ap.add_argument("--splits", nargs="*", default=["train","test"], help="Split directories to scan")
+    return ap.parse_args()
+
+def read_transcripts(path: Path):
+    id2pair = {}
+    if not path.exists():
+        print(f"[ERR] transcripts.txt not found: {path}", file=sys.stderr)
+        sys.exit(1)
+    with path.open(encoding="utf-8") as f:
+        reader = csv.reader(f, delimiter='|', quotechar='"')
+        for row in reader:
+            if not row or len(row) < 3: 
+                continue
+            rid, quz, es = row[0].strip(), row[1].strip(), row[2].strip()
+            id2pair[rid] = {"quz": quz, "es": es}
+            id2pair[rid.lstrip("0") or "0"] = {"quz": quz, "es": es}
+    print(f"[OK] transcripts loaded: {len(id2pair)//2} unique ids")
+    return id2pair
+
+def parse_lang_id(stem: str):
+    for rgx in PATTERNS:
+        m = rgx.search(stem)
+        if m:
+            g1, g2 = m.groups()
+            if g1.lower() in {"qu","es"}: return g1.lower(), g2
+            if g2.lower() in {"qu","es"}: return g2.lower(), g1
+    return None, None
+
+def _flatten_if_nested(sp_dir: Path, split_name: str):
+    """
+    If sp_dir contains a single subdir with the same name (train/test) or just one folder,
+    move its contents up to sp_dir and remove the nested dir.
+    """
+    if not sp_dir.exists():
+        return
+    # If there are files already at top-level, do nothing
+    top_files = [p for p in sp_dir.iterdir() if p.is_file()]
+    if top_files:
+        return
+    # Find immediate subdirs
+    subdirs = [p for p in sp_dir.iterdir() if p.is_dir()]
+    if len(subdirs) != 1:
+        return
+    nested = subdirs[0]
+    # Flatten only if nested is the same name or if sp_dir has exactly one subdir and no files
+    if nested.name == split_name or True:
+        for item in nested.iterdir():
+            item.rename(sp_dir / item.name)
+        nested.rmdir()
+
+def ensure_splits_exist_or_extract(root: Path, splits):
+    found_any = False
+    for sp in splits:
+        sp_dir = root / sp
+        sp_zip = root / f"{sp}.zip"
+
+        if sp_dir.exists():
+            found_any = True
+            continue
+
+        if sp_zip.exists() and zipfile.is_zipfile(sp_zip):
+            print(f"[INFO] Extracting {sp_zip} -> {sp_dir}")
+            sp_dir.mkdir(parents=True, exist_ok=True)
+            with zipfile.ZipFile(sp_zip, 'r') as zf:
+                zf.extractall(sp_dir)
+            _flatten_if_nested(sp_dir, sp)   # <-- add this line
+            found_any = True
+        else:
+            if sp_zip.exists():
+                print(f"[WARN] {sp_zip} exists but is not a valid zip (maybe an LFS pointer?). Skipping.")
+    return found_any
+
+
+def collect_rows(root: Path, splits, id2pair):
+    rows, counted = [], 0
+    missing_details, kept_missing, skipped_missing = [], 0, 0
+
+    have_split_dirs = any((root/sp).exists() for sp in splits)
+    if not have_split_dirs:
+        # try to auto-extract if zips exist
+        if ensure_splits_exist_or_extract(root, splits):
+            have_split_dirs = True
+
+    if have_split_dirs:
+        # standard split traversal
+        for sp in splits:
+            sp_dir = root / sp
+            if not sp_dir.exists():
+                print(f"[WARN] split folder not found: {sp_dir} (skipping)")
+                continue
+            for wav in sp_dir.rglob("*"):
+                if wav.suffix.lower() not in AUDIO_EXTS: continue
+                lang, idx = parse_lang_id(wav.stem)
+                if not idx or not lang: continue
+                pair = id2pair.get(idx) or id2pair.get(idx.lstrip("0") or "0")
+                tq = pair["quz"] if pair else None
+                te = pair["es"]  if pair else None
+                text = tq if lang == "qu" else te
+                rel = wav.relative_to(root).as_posix()
+                has_transcription = text is not None and text.strip() != ""
+                if not has_transcription:
+                    missing_details.append({
+                        "path": rel,
+                        "lang": lang,
+                        "id": idx,
+                        "split": sp
+                    })
+                    if sp in ALLOW_MISSING_TEXT_SPLITS:
+                        kept_missing += 1
+                    else:
+                        skipped_missing += 1
+                        continue
+                rows.append({
+                    "id": idx,
+                    "language": lang,
+                    "path": rel,
+                    "text": text,
+                    "has_transcription": has_transcription,
+                    "split": sp
+                })
+                counted += 1
+    else:
+        # no split dirs at all: index every wav under root as train
+        print("[INFO] No split folders found; indexing all audio under root as split='train'")
+        for wav in root.rglob("*"):
+            if wav.suffix.lower() not in AUDIO_EXTS: continue
+            lang, idx = parse_lang_id(wav.stem)
+            if not idx or not lang: continue
+            pair = id2pair.get(idx) or id2pair.get(idx.lstrip("0") or "0")
+            tq = pair["quz"] if pair else None
+            te = pair["es"]  if pair else None
+            text = tq if lang == "qu" else te
+            rel = wav.relative_to(root).as_posix()
+            has_transcription = text is not None and text.strip() != ""
+            if not has_transcription:
+                missing_details.append({
+                    "path": rel,
+                    "lang": lang,
+                    "id": idx,
+                    "split": "train"
+                })
+                if "train" in ALLOW_MISSING_TEXT_SPLITS:
+                    kept_missing += 1
+                else:
+                    skipped_missing += 1
+                    continue
+            rows.append({
+                "id": idx,
+                "language": lang,
+                "path": rel,
+                "text": text,
+                "has_transcription": has_transcription,
+                "split": "train"
+            })
+            counted += 1
+
+    print(f"[OK] audio files indexed: {counted}")
+    if kept_missing:
+        print(f"[INFO] samples kept without text: {kept_missing} (allowed splits: {', '.join(sorted(ALLOW_MISSING_TEXT_SPLITS))})")
+    if skipped_missing:
+        print(f"[WARN] samples skipped due to missing text: {skipped_missing}")
+    if missing_details:
+        for miss in missing_details[:10]:
+            flag = "kept" if miss["split"] in ALLOW_MISSING_TEXT_SPLITS else "skipped"
+            print(f"       - {miss['path']} (id={miss['id']}, lang={miss['lang']}, split={miss['split']}, {flag})")
+        if len(missing_details) > 10:
+            print(f"       ... {len(missing_details) - 10} more")
+    return rows
+
+def main():
+    args = parse_args()
+    root = args.root.resolve()
+    print(f"[INFO] repo root: {root}")
+    id2pair = read_transcripts(root / "transcripts.txt")
+    rows = collect_rows(root, args.splits, id2pair)
+    if not rows:
+        print("[ERR] no audio rows collected. Check paths, zips, or patterns.", file=sys.stderr)
+        sys.exit(2)
+
+    ds_all = Dataset.from_list(rows).cast_column("path", Audio(sampling_rate=None))
+
+    out_dir = root / "data"
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    splits_present = sorted({r["split"] for r in rows})
+    for sp in splits_present:
+        ds = ds_all.filter(lambda x: x["split"] == sp).remove_columns(["split"])
+        out = out_dir / f"{sp}.parquet"
+        ds.to_parquet(out)
+        print(f"[OK] wrote {out} ({len(ds)} rows)")
+
+    print("[DONE] Parquet build complete.")
+
+if __name__ == "__main__":
+    main()

data/test.parquet

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

data/train.parquet

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

quest.py

@@ -0,0 +1,73 @@
+# quest.py — for VoiceProfiler/QuEsT
+# Keeps `text_quz` (Quechua) and `text_es` (Spanish), plus a unified `text` column for the viewer.
+
+import os
+import datasets
+from datasets import load_dataset, Audio
+
+class QuEsT(datasets.GeneratorBasedBuilder):
+    VERSION = datasets.Version("1.0.0")
+    BUILDER_CONFIGS = [
+        datasets.BuilderConfig(name="default", version=VERSION, description="Default configuration"),
+    ]
+    DEFAULT_CONFIG_NAME = "default"
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description="Quechua–Spanish speech dataset (QuEsT) with aligned transcripts.",
+            features=datasets.Features({
+                "id":               datasets.Value("string"),
+                "language":         datasets.Value("string"),
+                "text":             datasets.Value("string"),
+                "has_transcription": datasets.Value("bool"),
+                "audio":            Audio(sampling_rate=None, mono=True),
+            }),
+        )
+
+    def _split_generators(self, dl_manager):
+        base = os.path.dirname(os.path.abspath(__file__))
+        return [
+            datasets.SplitGenerator(name=datasets.Split.TRAIN,
+                gen_kwargs={"parquet_path": os.path.join(base, "data", "train.parquet")}),
+            datasets.SplitGenerator(name=datasets.Split.TEST,
+                gen_kwargs={"parquet_path": os.path.join(base, "data", "test.parquet")}),
+        ]
+
+    def _generate_examples(self, parquet_path: str):
+        ds = load_dataset("parquet", data_files=parquet_path, split="train")
+
+        cols = set(ds.column_names)
+        length = len(ds)
+
+        # Normalize possible alternate column names
+        if "audio" in cols and "path" not in cols:
+            ds = ds.rename_column("audio", "path")
+        if "label" in cols and "text" not in cols:
+            ds = ds.rename_column("label", "text")
+        if "lang" in cols and "language" not in cols:
+            ds = ds.rename_column("lang", "language")
+        if "has_transcription" not in ds.column_names:
+            texts = ds["text"] if "text" in ds.column_names else [None] * length
+            default = [False if t in (None, "") else True for t in texts]
+            ds = ds.add_column("has_transcription", default)
+
+        # Ensure required columns exist
+        for c in ["id", "language", "text", "path", "has_transcription"]:
+            if c not in ds.column_names:
+                fill = [None] * length
+                if c == "has_transcription":
+                    fill = [False] * length
+                ds = ds.add_column(c, fill)
+
+        # Cast to Audio() for playback in viewer
+        ds = ds.cast_column("path", Audio(sampling_rate=None, mono=True))
+        ds = ds.rename_column("path", "audio")
+
+        # Keep only desired columns (and in order)
+        keep = ["id", "language", "text", "has_transcription", "audio"]
+        drop = [c for c in ds.column_names if c not in keep]
+        if drop:
+            ds = ds.remove_columns(drop)
+
+        for i, ex in enumerate(ds):
+            yield i, ex