Update README.md

README.md

@@ -1,3 +1,224 @@
----
-license: mit
----
+---
+license: mit
+---
+# Czech Synthetic Multiline Text Recognition Dataset
+
+A large-scale synthetic dataset for Czech multiline text recognition, containing 100,000 text images with corresponding transcriptions. Created using [SynthTiger](https://github.com/clovaai/synthtiger).
+
+## Dataset Description
+
+This dataset consists of synthetically generated images of Czech text with multiple lines per image, designed for training optical character recognition (OCR) models that can handle complex multiline text layouts. Each image contains approximately 10 lines of Czech text rendered with various fonts and alignments.
+
+### Dataset Statistics
+- **Total samples**: 100,000 image-text pairs
+- **Language**: Czech (cs_CZ)
+- **Lines per image**: ~10 lines
+- **Image format**: JPEG
+- **Storage format**: Parquet files (10 files total)
+- **Total size**: ~6.3 GB
+
+## Dataset Structure
+
+The dataset is organized into 10 Parquet files for efficient storage and loading:
+
+```
+data/
+├── train-00000-of-00010.parquet    # 10,000 samples
+├── train-00001-of-00010.parquet    # 10,000 samples
+├── ...
+├── train-00008-of-00010.parquet    # 10,000 samples
+└── train-00009-of-00010.parquet    # 10,000 samples
+```
+
+Each Parquet file contains two columns:
+- `image`: PIL Image object (JPEG format, properly typed for HuggingFace)
+- `text`: Ground truth text transcription (multiple lines)
+
+## Usage
+
+### Loading with Hugging Face Datasets
+
+```python
+from datasets import load_dataset
+
+# Load the entire dataset
+dataset = load_dataset("Empatixx/synth-text-recognition-multilines-cs")
+
+# Access samples
+sample = dataset['train'][0]
+image = sample['image']  # PIL Image object
+text = sample['text']    # Multiline text transcription
+
+# Load specific splits or streaming
+dataset = load_dataset("Empatixx/synth-text-recognition-multilines-cs", split="train[:1000]")  # First 1000 samples
+dataset = load_dataset("Empatixx/synth-text-recognition-multilines-cs", streaming=True)  # Stream the dataset
+```
+
+### Working with Multiline Text
+
+```python
+# Split text into individual lines
+sample = dataset['train'][0]
+lines = sample['text'].split('\n')
+print(f"Number of lines: {len(lines)}")
+for i, line in enumerate(lines):
+    print(f"Line {i+1}: {line}")
+```
+
+### PyTorch DataLoader Example
+
+```python
+from datasets import load_dataset
+from torch.utils.data import DataLoader
+from torchvision import transforms
+import torch
+
+# Load dataset
+dataset = load_dataset("Empatixx/synth-text-recognition-multilines-cs")
+
+# Define transforms
+transform = transforms.Compose([
+    transforms.Resize((512, 512)),  # Larger size for multiline text
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+])
+
+# Create DataLoader
+def collate_fn(batch):
+    images = [transform(sample['image']) for sample in batch]
+    texts = [sample['text'] for sample in batch]
+    return torch.stack(images), texts
+
+dataloader = DataLoader(
+    dataset['train'],
+    batch_size=16,  # Smaller batch size due to larger images
+    shuffle=True,
+    collate_fn=collate_fn
+)
+```
+
+### TrOCR Fine-tuning Example
+
+```python
+from transformers import TrOCRProcessor, VisionEncoderDecoderModel
+from datasets import load_dataset
+import torch
+
+# Load model and processor
+processor = TrOCRProcessor.from_pretrained("microsoft/trocr-base-handwritten")
+model = VisionEncoderDecoderModel.from_pretrained("microsoft/trocr-base-handwritten")
+
+# Load dataset
+dataset = load_dataset("Empatixx/synth-text-recognition-multilines-cs")
+
+# Preprocessing function
+def preprocess_function(examples):
+    # Process images
+    pixel_values = processor(images=examples['image'], return_tensors="pt").pixel_values
+    
+    # Process text labels
+    labels = processor.tokenizer(
+        examples['text'],
+        padding=True,
+        truncation=True,
+        max_length=512  # Longer for multiline text
+    ).input_ids
+    
+    return {
+        'pixel_values': pixel_values,
+        'labels': labels
+    }
+
+# Apply preprocessing
+processed_dataset = dataset.map(preprocess_function, batched=True)
+```
+
+## Generation Details
+
+The dataset was generated using SynthTiger with the following characteristics:
+
+### Text Sources
+- Czech words from Czech corpus (524,474 unique words)
+- Text lengths: 1-25 characters per line
+- Lines per image: 10 lines (configurable)
+- Character set: Full Czech alphabet including diacritics
+
+### Visual Variations
+- **Image size**: 1024x1024 pixels canvas
+- **Fonts**: Multiple font families with sizes 32-64px
+- **Font weight**: 50% probability of bold text
+- **Colors**: Black text on white background
+- **Text alignment**: Left, center, right, and justify
+- **Line spacing**: 0-16 pixels between lines
+- **Text case**: Lowercase, uppercase, and capitalized variations
+
+### Layout Properties
+- **Orientation**: Horizontal text (left-to-right)
+- **Line arrangement**: Top-to-bottom
+- **Text positioning**: Centered on canvas with variable line heights
+- **Real-world simulation**: Natural text flow with proper line breaks
+
+## Dataset Creation
+
+The dataset was created using the following process:
+
+1. **Text Selection**: Random selection of Czech words from corpus
+2. **Line Generation**: Combining words to create 10 lines per image
+3. **Layout Computation**: Calculating positions for multiline text rendering
+4. **Visual Rendering**: Text rendered with random fonts and alignments
+5. **Image Generation**: Creating final images with proper spacing and layout
+6. **Format Conversion**: Converting to HuggingFace-compatible Parquet format
+
+### Generation Command
+
+The dataset was generated using:
+```bash
+synthtiger -o results_100k_lines -c 100000 -w 8 -v examples/multiline/template.py Multiline examples/multiline/config.yaml
+```
+
+## Use Cases
+
+This multiline dataset is particularly suitable for:
+
+1. **Document OCR**: Training models for document text extraction
+2. **Multiline Recognition**: Models that need to handle multiple text lines
+3. **Layout Analysis**: Understanding text structure and organization
+4. **Czech Language Models**: Specialized OCR for Czech text
+5. **Benchmark Dataset**: Evaluating multiline OCR performance
+
+## Citation
+
+If you use this dataset, please cite:
+
+```bibtex
+@misc{czech-synth-multiline-text-2025,
+  title={Czech Synthetic Multiline Text Recognition Dataset},
+  author={Empatixx},
+  year={2025},
+  publisher={Hugging Face},
+  url={https://huggingface.co/datasets/Empatixx/synth-text-recognition-multilines-cs}
+}
+```
+
+Also cite the SynthTiger paper:
+
+```bibtex
+@inproceedings{yim2021synthtiger,
+  title={SynthTiger: Synthetic Text Image GEneratoR Towards Better Text Recognition Models},
+  author={Yim, Moonbin and Kim, Yoonsik and Cho, Han-Cheol and Park, Sungrae},
+  booktitle={International Conference on Document Analysis and Recognition},
+  pages={109--124},
+  year={2021},
+  organization={Springer}
+}
+```
+
+## License
+
+This dataset is released under the MIT license, following the SynthTiger licensing terms.
+
+## Acknowledgments
+
+- Dataset generated using [SynthTiger](https://github.com/clovaai/synthtiger)
+- Czech word corpus with 524,474 unique Czech words
+- Multiline template configuration for realistic document-like text layouts