Initial commit

README.md

@@ -6,39 +6,106 @@ configs:
   - split: train
     path: tars/train/*.tar
   - split: fine_tune
-    path: tars/train/*.tar
+    path: tars/fine_tune/*.tar
 language:
 - en
 ---
 
 # Accessing the `font-square-v2` Dataset on Hugging Face
 
-The `font-square-v2` dataset is hosted on Hugging Face at [blowing-up-groundhogs/font-square-v2](https://huggingface.co/datasets/blowing-up-groundhogs/font-square-v2). The dataset is stored in WebDataset format, with all tar files located in the `tars/` folder of the repository. Each tar file contains multiple samples; each sample includes:
-- An RGB image file (with the extension `.rgb.png`)
-- A black-and-white image file (with the extension `.bw.png`)
-- A JSON file (`.json`) with metadata (e.g. text and writer ID)
+The `font-square-v2` dataset is hosted on Hugging Face at [blowing-up-groundhogs/font-square-v2](https://huggingface.co/datasets/blowing-up-groundhogs/font-square-v2). It is stored in WebDataset format, with its tar files split into two folders:
+
+- **tars/train/**: Contains tar shards named `{000..499}.tar` for the main training split.
+- **tars/fine_tune/**: Contains tar shards named `{000..049}.tar` for optional fine-tuning.
+
+Each tar file includes multiple samples; each sample consists of:
+- An **RGB** image file (`.rgb.png`)
+- A **black-and-white** image file (`.bw.png`)
+- A **JSON** file (`.json`) with metadata (such as text, writer ID, etc.)
+
+You can access the dataset either by downloading it locally or by streaming it directly over HTTP.
+
+---
+
+## Table of Contents
+1. [Dataset Creation](#dataset-creation)
+2. [Downloading the Dataset Locally](#1-downloading-the-dataset-locally)
+   - [Using Git LFS](#using-git-lfs)
+   - [Using the huggingface_hub Python Library](#using-the-huggingface_hub-python-library)
+   - [Using WebDataset with the Local Files](#using-webdataset-with-the-local-files)
+3. [Streaming the Dataset Directly Over HTTP](#2-streaming-the-dataset-directly-over-http)
+4. [Additional Considerations](#additional-considerations)
+
+---
+
+## Dataset Creation
+
+### Text Content Sampling
+This synthetic dataset comprises images of text lines superimposed on diverse backgrounds. First, text lines are generated by sampling sentences from multiple English corpora available via the [NLTK](https://www.nltk.org/) library (for example, `abc`, `brown`, `genesis`, `inaugural`, `state_union`, and `webtext`).
+
+To better represent both common and rare characters, a **rarity-based weighting** strategy is used. Each word is assigned a weight based on the frequency of its individual characters (unigrams) and pairs of characters (bigrams). Words containing less frequent character patterns receive higher weights, so that they are sampled more often during dataset creation.
+
+Below is an example Python function used to compute the weight of a word:
+
+```python
+def word_weight(word):
+    # u_counts and b_counts are dictionaries storing
+    # unigram and bigram counts over the entire corpus.
+
+    # Compute the unigram score
+    u_score = 0
+    for c in word:
+        u_score += u_counts[c]
+    u_score /= len(word)
+    
+    # Compute the bigram score
+    bigrams = pairwise(' ' + word + ' ')
+    b_score = 0
+    for b in bigrams:
+        b_score += b_counts[''.join(b)]
+    b_score /= len(bigrams)
+
+    # Return the average of the two scores
+    return (u_score + b_score) / 2 
+```
+
+By sampling words using these computed weights, the resulting text exhibits a balanced distribution of characters, allowing the model to learn from both common and rare patterns.
 
-You can access the dataset in one of two ways: by downloading it locally or by streaming it directly over HTTP.
+### Text Line Rendering
+After a sentence is sampled, the image is created in two main steps:
+
+1. **Text Image Generation**:  
+   - A font is selected from a list of 100,000 fonts.
+   - The text is rendered on a white background to produce an initial grayscale text image.
+   
+2. **Background and Final Image Creation**:  
+   - A background image is chosen from a collection of realistic textures (such as paper, wood, or walls).
+   - A transparency value is randomly selected between 0.5 and 1.
+   - Random transformations (including rotation, warping, Gaussian blur, dilation, and color jitter) are applied to the text image.
+   - Minor transformations (such as dilation, color jitter, and random inversion) are applied to the background image.
+   - Finally, the processed text image is superimposed onto the background image using the chosen transparency, resulting in the final synthetic RGB image.
+
+In total, this process yields approximately 2.2 million text images. Each image has a fixed height of 64 pixels, while the width varies in proportion to the length of the text. Metadata for each image is stored in the accompanying JSON file.
 
 ---
 
 ## 1. Downloading the Dataset Locally
 
-You can download the dataset locally using either Git LFS or the [huggingface_hub](https://huggingface.co/docs/huggingface_hub) Python library.
+You can download the dataset locally using either **Git LFS** or the [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub) Python library.
 
-### **Using Git LFS**
+### Using Git LFS
 
-Clone the repository (make sure [Git LFS](https://git-lfs.github.com/) is installed):
+Clone the repository (ensure you have [Git LFS](https://git-lfs.github.com/) installed):
 
 ```bash
 git lfs clone https://huggingface.co/datasets/blowing-up-groundhogs/font-square-v2
 ```
 
-This will create a local directory named `font-square-v2` that contains the `tars/` folder with all the tar shards.
+This will create a local directory named `font-square-v2` that contains the `tars/` folder with the subdirectories `train/` and `fine_tune/`.
 
-### **Using the huggingface_hub Python Library**
+### Using the huggingface_hub Python Library
 
-Alternatively, you can download a snapshot of the dataset in your Python code:
+Alternatively, download a snapshot of the dataset with:
 
 ```python
 from huggingface_hub import snapshot_download
@@ -48,102 +115,106 @@ local_dir = snapshot_download(repo_id="blowing-up-groundhogs/font-square-v2", re
 print("Dataset downloaded to:", local_dir)
 ```
 
-After downloading, the tar shards are available in the `tars/` subdirectory of `local_dir`.
+After downloading, you will find the tar shards inside:
+- `local_dir/tars/train/{000..499}.tar`
+- `local_dir/tars/fine_tune/{000..049}.tar`
 
-### **Using WebDataset with the Local Files**
+### Using WebDataset with the Local Files
 
-Once the dataset is downloaded locally, you can load it with [WebDataset](https://github.com/webdataset/webdataset). For example:
+Once downloaded, you can load the dataset with [WebDataset](https://github.com/webdataset/webdataset). For example, to load the **training split**:
 
 ```python
 import webdataset as wds
 import os
-from pathlib import Path
 
-# Assuming the dataset was downloaded to `local_dir` and tar shards are in the 'tars' folder
-local_dir = "path/to/font-square-v2"  # Update this path if necessary
-tar_pattern = os.path.join(local_dir, "tars", "{000000..000499}.tar")  # Adjust range to match your tar shard naming
+local_dir = "path/to/font-square-v2"  # Update the path if necessary
 
-# Create a WebDataset
-dataset = wds.WebDataset(tar_pattern).decode("pil")
+# Load all training shards (000-499)
+train_pattern = os.path.join(local_dir, "tars", "train", "{000..499}.tar")
+train_dataset = wds.WebDataset(train_pattern).decode("pil")
 
-# Example: Iterate over a few samples
-for sample in dataset:
-    # Access sample items
-    rgb_image = sample["rgb.png"]  # RGB image (PIL image)
-    bw_image = sample["bw.png"]    # BW image (PIL image)
+for sample in train_dataset:
+    rgb_image = sample["rgb.png"]  # PIL image
+    bw_image = sample["bw.png"]    # PIL image
     metadata = sample["json"]
 
-    print("Sample metadata:", metadata)
-    
-    # Process the images as needed...
+    print("Training sample metadata:", metadata)
     break
 ```
 
+Similarly, load the **fine-tune** split with:
+
+```python
+fine_tune_pattern = os.path.join(local_dir, "tars", "fine_tune", "{000..049}.tar")
+fine_tune_dataset = wds.WebDataset(fine_tune_pattern).decode("pil")
+```
+
 ---
 
 ## 2. Streaming the Dataset Directly Over HTTP
 
-If you prefer to stream the dataset directly from Hugging Face (without downloading the entire dataset), you can use the HTTP URLs provided by the Hugging Face CDN. Make sure that your tar files are public and accessible.
-
-For example, if the tar shards are available at:
+If you prefer not to download all shards, you can stream them directly via HTTP using the Hugging Face CDN, provided the tar files are public.
 
+For example, if the training tar shards are available at:
 ```
-https://huggingface.co/datasets/blowing-up-groundhogs/font-square-v2/resolve/main/tars/000000.tar
-https://huggingface.co/datasets/blowing-up-groundhogs/font-square-v2/resolve/main/tars/000001.tar
+https://huggingface.co/datasets/blowing-up-groundhogs/font-square-v2/resolve/main/tars/train/000000.tar
 ...
+https://huggingface.co/datasets/blowing-up-groundhogs/font-square-v2/resolve/main/tars/train/000499.tar
 ```
-
-you can set up your WebDataset as follows:
+you can stream them as follows:
 
 ```python
 import webdataset as wds
 
-# Define the URL pattern to stream the tar shards directly from Hugging Face
-url_pattern = "https://huggingface.co/datasets/blowing-up-groundhogs/font-square-v2/resolve/main/tars/{000000..000499}.tar"
-# Adjust the shard range (here 000000 to 000010) to cover all your tar shards.
+url_pattern = (
+    "https://huggingface.co/datasets/blowing-up-groundhogs/font-square-v2/resolve/main"
+    "/tars/train/{000000..000499}.tar"
+)
 
-# Create a WebDataset that streams data
 dataset = wds.WebDataset(url_pattern).decode("pil")
 
-# Iterate over a few samples from the streamed dataset
 for sample in dataset:
     rgb_image = sample["rgb.png"]
     bw_image = sample["bw.png"]
     metadata = sample["json"]
 
     print("Sample metadata:", metadata)
-    
-    # Process sample as needed...
     break
 ```
 
-**Note:** Streaming performance depends on your network connection and the Hugging Face CDN. If you experience any slowdowns, consider downloading the dataset locally instead.
+(Adjust the shard range accordingly for the fine-tune split.)
 
 ---
 
 ## Additional Considerations
 
-- **Decoding:**  
-  The `.decode("pil")` method in the WebDataset pipeline converts image bytes into PIL images. If you prefer PyTorch tensors, you can add a transformation:
+- **Decoding**  
+  The `.decode("pil")` method in WebDataset converts image bytes into PIL images. If you prefer PyTorch tensors, you can add a transformation step:
   
   ```python
   import torchvision.transforms as transforms
   transform = transforms.ToTensor()
-  
+
   dataset = (
-      wds.WebDataset(url_pattern)
+      wds.WebDataset(train_pattern)
       .decode("pil")
       .map(lambda sample: {
           "rgb": transform(sample["rgb.png"]),
           "bw": transform(sample["bw.png"]),
-          "metadata": sample["json"],
+          "metadata": sample["json"]
       })
   )
   ```
 
-- **Shard Naming:**  
-  Ensure that the naming convention in your `tars/` folder matches the URL pattern used above. Adjust the pattern `{000000..000499}` accordingly if your tar files have a different naming scheme or if there are more shards.
-
----
+- **Shard Naming**  
+  The naming convention is now:
+  ```
+  tars/
+  ├── train/
+  │   └── {000..499}.tar
+  └── fine_tune/
+      └── {000..049}.tar
+  ```
+  Ensure that your WebDataset pattern matches this folder structure and tar file naming.
 
-By following these instructions, you can easily load and work with the `font-square-v2` dataset from Hugging Face in your Python projects using WebDataset.
+By following these instructions, you can easily integrate the `font-square-v2` dataset into your project for training and fine-tuning with a diverse set of synthetic text-line images.