Upload folder using huggingface_hub

README.md

@@ -1,21 +1,52 @@
 ---
-dataset_info:
-  features:
-  - name: title
-    dtype: string
-  - name: text
-    dtype: string
-  - name: duration
-    dtype: float64
-  splits:
-  - name: train
-    num_bytes: 12569709929
-    num_examples: 41360289
-  download_size: 6851688816
-  dataset_size: 12569709929
-configs:
-- config_name: default
-  data_files:
-  - split: train
-    path: data/train-*
+license: cc-by-sa-4.0
 ---
+
+# Wikipedia Utterances
+
+Text segments extracted from English Wikipedia, segmented into utterance-length chunks suitable for text-to-speech synthesis.
+
+## Dataset Description
+
+This dataset contains ~41M text utterances derived from the [wikimedia/wikipedia](https://huggingface.co/datasets/wikimedia/wikipedia) dataset (20231101.en snapshot). Each row contains:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `title` | string | The Wikipedia article title |
+| `text` | string | A text segment (10-4,880 characters) |
+| `duration` | float | Estimated speech duration in seconds (at 150 WPM) |
+
+## Processing
+
+The transformation pipeline:
+
+1. Tokenizes Wikipedia articles into paragraphs and sentences using NLTK
+2. Combines consecutive sentences targeting 15-30 second utterances
+3. Strips bracketed content (parentheses, braces, square brackets)
+4. Filters for valid utterances ending in sentence-final punctuation
+
+See `transform_wikipedia.py` in this repository for the full implementation.
+
+## Usage
+
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("jspaulsen/wikipedia-utterances", split="train")
+```
+
+## License
+
+This dataset is released under [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/), consistent with the original Wikipedia content license.
+
+## Citation
+
+If you use this dataset, please cite the original Wikimedia source:
+
+```bibtex
+@ONLINE{wikidump,
+    author = "Wikimedia Foundation",
+    title  = "Wikimedia Downloads",
+    url    = "https://dumps.wikimedia.org"
+}
+```

pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "wikipedia-transform"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "datasets>=4.4.1",
+    "huggingface>=0.0.1",
+    "huggingface-hub>=1.2.3",
+    "nltk>=3.9.2",
+    "numpy>=2.3.5",
+]

transform_wikipedia.py

@@ -0,0 +1,189 @@
+import nltk
+from nltk.tokenize import sent_tokenize, BlanklineTokenizer
+from datasets import load_dataset
+import pyarrow as pa
+import pyarrow.parquet as pq
+import re
+from pathlib import Path
+
+
+nltk.download('punkt')
+nltk.download('punkt_tab')
+
+
+def strip_brackets(text: str) -> str:
+    """
+    Remove parentheses (), braces {}, and brackets [] along with their contents.
+    """
+    text = re.sub(r'\([^)]*\)', '', text)
+    text = re.sub(r'\{[^}]*\}', '', text)
+    text = re.sub(r'\[[^\]]*\]', '', text)
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+
+def is_valid_utterance(
+    utterance: str,
+    minimum_utterance_length: int = 10,
+) -> bool:
+    utterance = utterance.strip(' ').strip('\n')
+
+    if utterance.count('\n') > 1:
+        return False
+
+    if len(utterance) < minimum_utterance_length:
+        return False
+
+    if not utterance.endswith(('.', '!', '?')):
+        if not utterance.endswith(('"', "'")):
+            return False
+        if len(utterance) >= 2:
+            if utterance[-2] not in ('.', '!', '?'):
+                return False
+
+    if any(char in utterance for char in '(){}[]'):
+        return False
+
+    return True
+
+
+def estimate_speech_duration(text: str, wpm: int = 150) -> float:
+    """
+    Estimate speech duration in seconds.
+    Average speaking rate is ~150 words per minute.
+    """
+    words = text.split()
+    return (len(words) / wpm) * 60
+
+
+def combine_sentences_in_paragraph(
+    sentences: list[str],
+    min_duration: float = 15.0,
+    max_duration: float = 30.0,
+) -> list[str]:
+    """
+    Combine consecutive sentences within a paragraph if the combined duration
+    falls between min_duration and max_duration seconds.
+    """
+    if not sentences:
+        return []
+
+    result = []
+    current_chunk = []
+    current_duration = 0.0
+
+    for sentence in sentences:
+        sentence_duration = estimate_speech_duration(sentence)
+        potential_duration = current_duration + sentence_duration
+
+        if potential_duration <= max_duration:
+            current_chunk.append(sentence)
+            current_duration = potential_duration
+        else:
+            if current_chunk:
+                result.append(' '.join(current_chunk))
+            current_chunk = [sentence]
+            current_duration = sentence_duration
+
+    if current_chunk:
+        result.append(' '.join(current_chunk))
+
+    return result
+
+
+def transform_text(text: str) -> list[str]:
+    """
+    Transform Wikipedia text into valid utterances.
+    Returns a list of valid utterance strings.
+    """
+    paragraph_tokenizer = BlanklineTokenizer()
+    paragraphs = paragraph_tokenizer.tokenize(text)
+
+    valid_utterances = []
+
+    for segment in paragraphs:
+        sentences = sent_tokenize(segment)
+        combined_sentences = combine_sentences_in_paragraph(sentences)
+
+        for sentence in combined_sentences:
+            if is_valid_utterance(sentence):
+                valid_utterances.append(sentence)
+
+    return valid_utterances
+
+
+def process_example(example: dict) -> list[dict]:
+    """
+    Process a single Wikipedia example, transforming the 'text' field
+    into individual utterance rows.
+    """
+    utterances = transform_text(example['text'])
+    return [
+        {
+            'title': example['title'],
+            'text': utterance,
+            'duration': estimate_speech_duration(utterance),
+        }
+        for utterance in utterances
+    ]
+
+
+def flush_batch(rows: list[dict], output_dir: Path, shard_index: int) -> None:
+    """Write a batch of rows to a Parquet shard."""
+    if not rows:
+        return
+
+    table = pa.Table.from_pydict({
+        'title': [r['title'] for r in rows],
+        'text': [r['text'] for r in rows],
+        'duration': [r['duration'] for r in rows],
+    })
+
+    shard_path = output_dir / f"shard_{shard_index:05d}.parquet"
+    pq.write_table(table, shard_path)
+    print(f"  Wrote shard {shard_index} with {len(rows)} utterances")
+
+
+def main():
+    output_dir = Path('wikipedia_utterances')
+    output_dir.mkdir(exist_ok=True)
+
+    batch_size = 100_000  # Flush to disk every 100k utterances
+
+    print("Loading Wikipedia dataset...")
+    dataset = load_dataset(
+        'wikimedia/wikipedia',
+        '20231101.en',
+        split='train',
+        streaming=True,
+    )
+
+    print("Processing dataset...")
+    rows = []
+    shard_index = 0
+    total_utterances = 0
+
+    for i, example in enumerate(dataset):
+        utterance_rows = process_example(example)
+        rows.extend(utterance_rows)
+
+        if len(rows) >= batch_size:
+            flush_batch(rows, output_dir, shard_index)
+            total_utterances += len(rows)
+            shard_index += 1
+            rows = []
+
+        if (i + 1) % 10_000 == 0:
+            print(f"Processed {i + 1} articles, {total_utterances + len(rows)} utterances so far")
+
+    # Flush remaining rows
+    if rows:
+        flush_batch(rows, output_dir, shard_index)
+        total_utterances += len(rows)
+
+    print(f"\nDone! Saved {total_utterances} utterances across {shard_index + 1} shards to '{output_dir}/'")
+    print(f"Load with: load_dataset('parquet', data_files='{output_dir}/*.parquet')")
+
+
+if __name__ == "__main__":
+    main()