Deploy fully comprehensive Dataset Card with tensor schemas and extraction details

README.md

@@ -7,6 +7,8 @@ tags:
 - qwen2.5
 - block-diffusion
 - non-autoregressive
+- gsm8k
+- chain-of-thought
 size_categories:
 - 10K<n<100K
 task_categories:
@@ -19,60 +21,91 @@ language:
 
 [![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![Base Model](https://img.shields.io/badge/Base%20LLM-Qwen2.5--0.5B--Instruct-green.svg)](https://huggingface.co/Qwen/Qwen2.5-0.5B-Instruct)
-[![HuggingFace Model](https://img.shields.io/badge/HF%20Model-tahamajs%2FBlockDiffuse-yellow.svg)](https://huggingface.co/tahamajs/BlockDiffuse)
-[![HuggingFace Space](https://img.shields.io/badge/HF%20Space-BlockDiffuse--Blog-blueviolet.svg)](https://huggingface.co/spaces/tahamajs/BlockDiffuse-Blog)
+[![HuggingFace Model](https://img.shields.io/badge/HF%20Model-Hooshaai%2FBlockDiffuse-yellow.svg)](https://huggingface.co/Hooshaai/BlockDiffuse)
+[![HuggingFace Space](https://img.shields.io/badge/HF%20Space-BlockDiffuse--Blog-blueviolet.svg)](https://huggingface.co/spaces/Hooshaai/BlockDiffuse-Blog)
 
-This repository contains the complete pre-extracted dataset files used to train **BlockDiffuse** Diffusion Transformers to generate **100-token blocks in continuous latent space** using **Rectified Flow Matching**.
+This repository hosts the complete suite of pre-tokenized reasoning datasets and continuous latent trajectory representations extracted from **`Qwen/Qwen2.5-0.5B-Instruct`** for training **BlockDiffuse** Diffusion Transformers via **Rectified Flow Matching**.
 
 ---
 
-## 🔬 Dataset Overview & Extraction Pipeline
+## 📑 Table of Contents
+1. [Dataset Pipeline & Extraction Architecture](#1-dataset-pipeline--extraction-architecture)
+2. [Dataset Files Manifest & Specifications](#2-dataset-files-manifest--specifications)
+3. [Data Formats & Internal Tensor Keys](#3-data-formats--internal-tensor-keys)
+4. [How to Load and Inspect with PyTorch](#4-how-to-load-and-inspect-with-pytorch)
+5. [End-to-End Training Instructions](#5-end-to-end-training-instructions)
+6. [Citation](#6-citation)
 
-Standard language models operate over discrete token vocabularies ($V \approx 151{,}936$). To bypass sequential autoregressive decoding, BlockDiffuse maps prompts and target answer sequences into continuous latent vectors:
+---
+
+## 1. Dataset Pipeline & Extraction Architecture
+
+Modern LLMs operate over discrete token vocabularies ($V = 151{,}936$). To train a Diffusion Transformer to denoise entire sequences simultaneously, BlockDiffuse maps prompts and target answers into continuous representation vectors:
 
 ```
-Discrete Prompt Tokens (L_p) ──► Qwen2.5-0.5B (Layer 12) ──► Prompt Latents c [L_p x 896]
-Discrete Target Tokens (100) ──► Qwen2.5-0.5B (Layer 12) ──► Target Latents z_1 [100 x 896]
+Discrete Prompt Tokens (L_p) ──► Qwen2.5 (Layers 1..12) ──► Prompt Latents c [L_p x 896]
+Discrete Target Tokens (100) ──► Qwen2.5 (Layers 1..12) ──► Target Latents z_1 [100 x 896]
 ```
 
-These precomputed continuous tensors allow training the Diffusion Transformer directly on latent trajectory matching without re-computing LLM forward passes on every iteration, accelerating training throughput by **> 12x**.
+By precomputing and persisting these continuous tensors to disk, BlockDiffuse eliminates redundant forward passes through the LLM during training, boosting training throughput by **> 12x** on single-GPU hardware.
 
 ---
 
-## 📁 File Manifest & Specifications
+## 2. Dataset Files Manifest & Specifications
 
-| File Name | File Size | Description | Shape / Keys |
-| :--- | :--- | :--- | :--- |
-| `reasoning_tokenized_qwen.pt` | **12.5 MB** | Pre-tokenized GSM8K & Math reasoning conversations formatted with the Qwen2.5 ChatML template (`<\|im_start\|>...<\|im_end\|>`). | `input_ids`, `attention_mask`, `labels` |
-| `precomputed_reasoning_latents_qwen.pt` | **69.1 MB** | Validation subset of continuous target latents ($z_1$) and prompt conditionings ($c$) extracted from Layer 12 of Qwen2.5. | `{"prompt_latents": [N, L_p, 896], "target_latents": [N, 100, 896]}` |
-| `precomputed_real_qwen.pt` | **1,045.9 MB** | Intermediate-scale latent training dataset containing 1,000 multi-turn mathematical reasoning trajectories. | `{"prompt_latents", "target_latents", "target_tokens"}` |
-| `precomputed_real_qwen_full.pt` | **2,360.3 MB** | Complete production training dataset covering extensive multi-step reasoning problems. | `{"prompt_latents", "target_latents", "target_tokens"}` |
+| File Name | File Size | Description | Target Tasks | Samples Count |
+| :--- | :--- | :--- | :--- | :--- |
+| `reasoning_tokenized_qwen.pt` | **13.1 MB** | Pre-tokenized GSM8K & Math reasoning traces formatted using the Qwen2.5 ChatML format (`<\|im_start\|>system...user...assistant<\|im_end\|>`). | Token-level evaluation & tokenized baseline training | ~10,000 samples |
+| `precomputed_reasoning_latents_qwen.pt` | **72.4 MB** | Validation subset of continuous target latents ($z_1 \in \mathbb{R}^{B \times 100 \times 896}$) and prompt conditionings ($c \in \mathbb{R}^{B \times L_p \times 896}$). | Rapid model validation & loss metric evaluation | 1,000 trajectories |
+| `precomputed_real_qwen.pt` | **1,045.9 MB** | Intermediate-scale latent training dataset containing multi-turn mathematical reasoning trajectories. | Medium-scale training (1,000–5,000 steps) | 1,000 long traces |
+| `precomputed_real_qwen_full.pt` | **2,360.3 MB** | Complete production-scale training set covering multi-step mathematical and algorithmic reasoning problems. | Full-scale training (20,000 steps) | Full GSM8K + Math traces |
 
 ---
 
-## 🚀 How to Load and Use
+## 3. Data Formats & Internal Tensor Keys
+
+Each `.pt` file is a serialized Python dictionary with the following tensor schema:
+
+```python
+{
+    "prompt_latents": torch.Tensor,   # Shape: [N, max_prompt_len, 896] (float32 / bfloat16)
+    "target_latents": torch.Tensor,   # Shape: [N, 100, 896] (Target latents z_1 at Layer 12)
+    "target_tokens": torch.Tensor,    # Shape: [N, 100] (Ground truth discrete token IDs for CE loss)
+    "prompt_lens": torch.Tensor,      # Shape: [N] (Exact token length of each prompt prefix)
+}
+```
+
+---
+
+## 4. How to Load and Inspect with PyTorch
 
-### 1. Direct Python Loading via `torch.load`
 ```python
 import torch
 
-# Load tokenized sequences
-tokenized_data = torch.load("reasoning_tokenized_qwen.pt", map_location="cpu")
-print("Tokenized sample count:", len(tokenized_data["input_ids"]))
+# 1. Inspect Tokenized Sequences
+tokenized = torch.load("reasoning_tokenized_qwen.pt", map_location="cpu")
+print("Total tokenized entries:", len(tokenized["input_ids"]))
+print("Sample input_ids shape:", tokenized["input_ids"][0].shape)
 
-# Load precomputed continuous latents
-latents_data = torch.load("precomputed_reasoning_latents_qwen.pt", map_location="cpu")
-print("Prompt latents shape:", latents_data["prompt_latents"][0].shape)  # [L_p, 896]
-print("Target latents shape:", latents_data["target_latents"][0].shape)  # [100, 896]
+# 2. Inspect Continuous Latents
+latents = torch.load("precomputed_reasoning_latents_qwen.pt", map_location="cpu")
+print("Prompt latents shape:", latents["prompt_latents"].shape)  # [N, L_p, 896]
+print("Target latents shape:", latents["target_latents"].shape)  # [N, 100, 896]
+print("Target tokens shape:", latents["target_tokens"].shape)    # [N, 100]
 ```
 
-### 2. Training BlockDiffuse DiT with this Dataset
+---
+
+## 5. End-to-End Training Instructions
+
+To train a BlockDiffuse DiT model from scratch using these precomputed latents:
+
 ```bash
-# Clone official codebase
+# 1. Clone official repository
 git clone https://github.com/Hooshaai/BlockDiffuse.git
 cd BlockDiffuse
 
-# Train with the precomputed full dataset
+# 2. Train with the full precomputed dataset
 python train.py \
     --config_train configs/gpu_full_capacity_improved.yaml \
     --config_dit configs/gpu_full_capacity_improved.yaml \
@@ -83,14 +116,8 @@ python train.py \
 
 ---
 
-## 📐 Latent Space Normalization & Properties
-- **Dimensionality**: $d_{\text{model}} = 896$ per token position.
-- **Layer Origin**: Extracted after RMSNorm from Transformer Block 12 of `Qwen2.5-0.5B-Instruct`.
-- **Target Block Length**: Exactly 100 contiguous tokens. Shorter sequences are padded to 100 with EOS token latents; longer reasoning traces are chunked with rolling context propagation.
-
----
+## 6. Citation
 
-## 📜 Citation
 ```bibtex
 @article{blockdiffuse2026,
   title={BlockDiffuse: Fully Parallel Latent Space Reasoning Generation with Diffusion Transformers},