Update README.md

README.md

@@ -1,71 +1,63 @@
----
-license: mit
-task_categories:
-- text-classification
-- question-answering
-tags:
-- agent
-size_categories:
-- 1K<n<10K
----
-# Model Card: Streaming Terminal Log Boundary Predictor (Phi-4 LoRA)
-
-## 🤖 Model Details
-* **Base Model:** `unsloth/Phi-4-unsloth-bnb-4bit` (14B Parameters)
-* **Architecture:** LoRA Adapters (PEFT)
-* **Task:** Binary Classification (Terminal Event Boundary Detection)
-* **Quantization:** 4-bit (bitsandbytes)
-* **Language:** English / Bash / Terminal XML
-
-## 🎯 Intended Use
-This model is designed to parse continuous, timestamped terminal logs formatted in XML and determine if a specific line represents a "Boundary." 
-* **New Event:** The start of a new phase (e.g., a new user prompt appearing, or a transition from downloading to extracting).
-* **Old Event:** A continuation of an ongoing process or a user keystroke (e.g., pressing Enter).
-
-This is particularly useful for segmenting long, automated build logs (like `apt-get` installations or mirror syncs) into readable, distinct chronological events.
-
-## 🗂️ Training Data
-The model was fine-tuned on the **[Jaiccc/model0_boundary_predict_streaming](https://huggingface.co/datasets/Jaiccc/model0_boundary_predict_streaming)** dataset. 
-
-The data utilizes a **sliding-window context of 15 chunks**:
-* 14 chunks of historical context.
-* 1 Target chunk to classify.
-* Heavily imbalanced data was downsampled to a 2:1 (Old:New) ratio to prevent majority-class guessing.
-
-## 💻 How to Use (Inference)
-Because this is a private repository, you must authenticate using your Hugging Face token. This model uses PEFT/LoRA, meaning it is highly memory-efficient.
-
-```python
-import re
-from unsloth import FastLanguageModel
-from google.colab import userdata
-
-# 1. Retrieve your secure token
-hf_token = userdata.get('HF_TOKEN') # Or os.getenv("HF_TOKEN")
-
-# 2. Load the Fine-Tuned Model
-model, tokenizer = FastLanguageModel.from_pretrained(
-    model_name = "Jaiccc/model_0_streaming_timestamp",
-    max_seq_length = 4096,
-    load_in_4bit = True,
-    token = hf_token, 
-)
-FastLanguageModel.for_inference(model)
-
-# 3. Format your prompt (ChatML)
-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_data = "### CONTEXT (Previous Events):\n<system_output timestamp=\"10.01\">demo@server:~$ apt update</system_output>\n\n### TARGET LINE:\n<user_input timestamp=\"12.40\">s</user_input>"
-
-prompt = f"<|im_start|>user<|im_sep|>{instruction}\n\n{input_data}<|im_end|><|im_start|>assistant<|im_sep|>"
-inputs = tokenizer(prompt, return_tensors="pt").input_ids.to("cuda")
-
-# 4. Generate Prediction
-outputs = model.generate(input_ids=inputs, max_new_tokens=64, use_cache=True, temperature=0.1)
-raw_output = tokenizer.batch_decode(outputs, clean_up_tokenization_spaces=True)[0]
-
-# 5. Extract Result
-m = re.search(r'<\|im_start\|>assistant<\|im_sep\|>(.*?)<\|im_end\|>', raw_output, re.S)
-result = m.group(1).strip() if m else raw_output.split("assistant")[-1].strip()
-
-print(result)
-# Expected Output: "12.40, old event"
+# 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. 
+
+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.
+
+## 🗂️ 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"
+}
+🎯 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").
+
+✂️ 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:
+
+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.
+
+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.
+
+⚖️ Data Sampling & Balancing
+In a typical terminal log, over 95% of the lines are "Old Events" (continuous output or typing), 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).
+
+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.
+
+💻 How to Load the Dataset
+You can load this dataset directly in Python using the Hugging Face datasets library:
+
+Python
+from datasets import load_dataset
+
+# Load the dataset
+dataset = load_dataset("Jaiccc/model0_boundary_predict_streaming", split="train")
+
+# Optional: Split into training and validation
+split = dataset.train_test_split(test_size=0.1, seed=42)
+train_dataset = split["train"]
+eval_dataset = split["test"]