Update README.md

README.md

@@ -1,53 +1,80 @@
-# Dataset Card: Terminal Log Boundary Prediction (Streaming)
+# ## Dataset Card: Terminal Log Boundary Prediction (Streaming)
 
-## 📋 Dataset Summary
-This dataset is designed to train Large Language Models (LLMs) to detect phase transitions, or "boundaries," within continuous, timestamped terminal XML logs. 
+### 📋 Dataset Summary
+This dataset is designed to train Large Language Models (LLMs) to detect 
+phase transitions, or **"boundaries,"** within continuous terminal XML logs.
 
-Instead of reading a massive log file all at once, the dataset is structured using a **sliding-window approach**. The model is fed a short history of terminal events and must determine if the **very last line** (the Target Line) represents the start of a new phase/event or just the continuation of an ongoing process.
+The dataset uses a **sliding-window approach**. Instead of reading a 
+massive log file at once, the model analyzes a short history of events 
+to determine if the **Target Line** (the final entry) marks a new 
+logical event or the continuation of an ongoing process.
 
-## 🗂️ Dataset Structure
-The dataset is provided in `JSONL` format, mapped specifically for conversational instruction-tuning (like ChatML). Each row contains three fields:
-
-* **`instruction`**: The static system prompt that explicitly defines what makes a "new event" (e.g., shell prompts returning, phase transitions in automated scripts) versus an "old event" (e.g., a user pressing the Enter key, continuous downloading).
-* **`input`**: The sliding-window terminal data. It is separated into two blocks:
-    * `### CONTEXT (Previous Events):` Up to 14 historical XML chunks to help the model understand the current state of the terminal.
-    * `### TARGET LINE (Extract and Classify THIS Timestamp):` The 15th chunk containing the specific timestamp the model needs to evaluate.
-* **`label / output`**: The ground-truth prediction formatted strictly as `{timestamp}, {class} event`.
+---
 
-### Example Data Row
-```json
-{
-  "instruction": "Your task is to analyze terminal XML logs and determine whether the timestamp in the TARGET LINE belongs to a \"new event\" or an \"old event\"...",
-  "input": "### CONTEXT (Previous Events):\n<system_output timestamp=\"10.01\">demo@server:~$ apt update</system_output>\n<system_output timestamp=\"10.05\">Reading package lists...</system_output>\n\n### TARGET LINE:\n<user_input timestamp=\"12.40\">s</user_input>",
-  "output": "12.40, old event"
-}
+### 🗂️ Dataset Structure
+The dataset is in `JSONL` format, optimized for ChatML instruction-tuning. 
+Each row contains three primary fields:
 
----
+* **`instruction`**: The system prompt defining "new" vs. "old" events.
+* **`input`**: The sliding-window data, split into:
+    * `### CONTEXT`: Up to 14 historical XML chunks.
+    * `### TARGET LINE`: The 15th chunk to be classified.
+* **`label / output`**: Formatted as `{timestamp}, {class} event`.
 
 ### 🎯 The Model's Goal
-The primary objective of the model is **binary classification of sequential data**. By looking at the historical context (e.g., "The terminal has been downloading packages for the last 14 steps"), the model must predict if the timestamp in the Target Line breaks that pattern and establishes a new boundary (e.g., "The download finished and the shell prompt returned").
+The primary objective of the model is **binary classification of sequential data**. 
+By looking at the historical context (e.g., "The terminal has been downloading 
+packages for the last 14 steps"), the model must predict if the timestamp in 
+the Target Line breaks that pattern and establishes a new boundary (e.g., 
+"The download finished and the shell prompt returned").
 
 ---
 
 ### ✂️ Rules of Truncation
-Raw terminal logs (like `apt-get` installations) can easily overflow an LLM's context window. To prevent this, the data engineering pipeline applies a strict **Two-Phase Truncation** rule:
+Raw terminal logs (like `apt-get` installations) can easily overflow an LLM's 
+context window. To prevent this, the data engineering pipeline applies a 
+strict **Two-Phase Truncation** rule:
 
 #### Phase 1: Intra-Chunk Truncation (Line Limit)
-If a single `<system_output>` block contains more than 15 lines of text, it is sliced. The first 5 lines and the last 5 lines are preserved, and the middle is replaced with a marker: `... [TRUNCATED X LINES] ...`. Note that `<user_input>` tags are **never** truncated to preserve human-interaction signals.
+If a single `<system_output>` block contains more than 15 lines of text, it 
+is sliced. The first 5 lines and the last 5 lines are preserved, and the 
+middle is replaced with a marker: `... [TRUNCATED X LINES] ...`. Note 
+that `<user_input>` tags are **never** truncated to preserve 
+human-interaction signals.
 
 #### Phase 2: Window-Level Compression (Context Limit)
-If the entire 14-chunk context window exceeds 25 total lines, the window is compressed:
-* The **5 oldest chunks** and the **5 most recent chunks** are kept fully intact.
-* For the chunks in the **middle**, the text is completely stripped out, leaving only the XML tags (e.g., `<system_output timestamp="X">... [TRUNCATED TO SAVE SPACE] ...</system_output>`).
-* This preserves the chronological timeline and sequence of events without bloating the token count.
+If the entire 14-chunk context window exceeds 25 total lines, the window 
+is compressed:
+* The **5 oldest chunks** and the **5 most recent chunks** are kept 
+  fully intact.
+* For the chunks in the **middle**, the text is completely stripped out, 
+  leaving only the XML tags (e.g., `<system_output timestamp="X">... 
+  [TRUNCATED TO SAVE SPACE] ...</system_output>`).
+* This preserves the chronological timeline and sequence of events 
+  without bloating the token count.
 
 ---
 
 ### ⚖️ Data Sampling & Balancing
-In a typical terminal log, over 95% of the lines are "Old Events," which would lead the model to simply guess the majority class. To force actual learning, this dataset uses **Negative Downsampling**:
+In a typical terminal log, over 95% of the lines are "Old Events," which 
+would lead the model to simply guess the majority class. To force actual 
+learning, this dataset uses **Negative Downsampling**:
 
 * **New Events (Positives):** 100% of detected boundaries are kept.
-* **Old Events (Negatives):** Downsampled so that there is exactly a **2:1 ratio** (Two old events for every one new event).
+* **Old Events (Negatives):** Downsampled so that there is exactly a 
+  **2:1 ratio** (Two old events for every one new event).
 
 #### Hard Negative Mining
-When selecting which "Old Events" to keep for the 2:1 ratio, the algorithm prioritizes **Hard Negatives**. Specifically, it targets `<user_input>` tags that contain a newline character (`\n`). This teaches the model the difficult lesson that a user pressing "Enter" is often just a completion of an input phase, not necessarily a new logical event.
+When selecting which "Old Events" to keep for the 2:1 ratio, the algorithm 
+prioritizes **Hard Negatives**. Specifically, it targets `<user_input>` 
+tags that contain a newline character (`\n`). This teaches the model the 
+difficult lesson that a user pressing "Enter" is often just a completion 
+of an input phase, not necessarily a new logical event.
+
+#### Example Data Row
+```json
+{
+  "instruction": "Your task is to analyze terminal XML logs...",
+  "input": "### CONTEXT (Previous Events):\n<system_output timestamp=\"10.01\">demo@server:~$ apt update</system_output>\n<system_output timestamp=\"10.05\">Reading lists...</system_output>\n\n### TARGET LINE:\n<user_input timestamp=\"12.40\">s</user_input>",
+  "output": "12.40, old event"
+}