add vdb, train_llm

.gitattributes

@@ -1,5 +1,5 @@
 *.csv filter=lfs diff=lfs merge=lfs -text
-
+*.jsonl filter=lfs diff=lfs merge=lfs -text
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
@@ -58,4 +58,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+llm/complete_dataset.jsonl filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+venv
+temp_data

classification/train_ml.ipynb

@@ -10,23 +10,45 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "8bb0209c-63c4-4601-894c-0ded8f4db2e6",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "d:\\sumobot\\sumobot_ml\\venv\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
    "source": [
-    "import os\n",
+    "import sys, os\n",
+    "sys.path.append(os.path.abspath(\"..\"))\n",
+    "\n",
     "import numpy as np\n",
     "import pandas as pd\n",
     "import glob\n",
+    "from dataset_helper import get_dataset, get_dataset_dir\n",
+    "\n",
     "\n",
     "# Amount of dataset lines that will be compiled and converted to dataset.jsonl. \n",
     "# If -1, use all lines.\n",
-    "max_dataset=100\n",
-    "# max_dataset=-1\n",
+    "# max_dataset=100\n",
+    "max_dataset=-1\n",
     "\n",
     "output_onnx_name = \"ml.onnx\"\n",
-    "output_labels_name = \"ml_labels.json\"\n"
+    "output_labels_name = \"ml_labels.json\"\n",
+    "\n",
+    "# Load & process data\n",
+    "\n",
+    "df, dir = get_dataset(inside_arena=True)\n",
+    "\n",
+    "# df.to_csv(f\"{get_dataset_dir()}/merged.csv\", index=False)\n",
+    "\n",
+    "if max_dataset>-1:\n",
+    "    df = df.sample(max_dataset)\n"
    ]
   },
   {
@@ -231,7 +253,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "sumobot_slm",
+   "display_name": "venv",
    "language": "python",
    "name": "python3"
   },
@@ -245,7 +267,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.18"
+   "version": "3.12.10"
   }
  },
  "nbformat": 4,

dataset_helper.py

@@ -322,11 +322,17 @@ def export_dataset(df, output_path, format="txt", completion_mode="normal", incl
                     }
                     f.write(json.dumps(record) + "\n")
                 elif format == "jsonl_text":
-                    line = f"You are a Sumobot assistant. Given this state: {prompt_str} Suggested Action: {', '.join(actions)}"
+                    line = f"<INST> state: {prompt_str}</INST> {', '.join(actions)}"
                     record = {
                         "text": line,
                     }
                     f.write(json.dumps(record) + "\n")
+                elif format == "state_action":
+                    record = {
+                        "state": prompt_str,
+                        "action": ', '.join(actions),
+                    }
+                    f.write(json.dumps(record) + "\n")
                 
 
             except Exception as e:
@@ -373,6 +379,8 @@ def get_dataset(
         print(f"Reading local dataset from: {local_dataset_path}")
         csv_files = glob.glob(os.path.join(local_dataset_path, "*.csv"))
         for fname in csv_files:
+            if not os.path.basename(fname).startswith("game_logs"):
+                continue
             df = pd.read_csv(fname)
             df["source_file"] = os.path.basename(fname)
             dfs.append(df)
@@ -418,3 +426,91 @@ def get_dataset_from_hf(
             df.to_csv(save_path, index=False)
             print(f"Saved: {save_path}")
     return dfs
+
+def sample_dataset(
+        input_file: str,
+        train_output: str,
+        val_output: str,
+        max_lines: int,
+        action_ratio: dict[str, float],
+        train_ratio: float = 0.85,
+    ):
+
+    df = pd.read_json(input_file, lines=True)
+
+    lines = (df.shape[0] if max_lines == -1 else max_lines)
+    print(lines)
+
+    if max_lines ==-1 or action_ratio is None:
+        split_idx = int(len(df) * train_ratio)
+        train_df = df.iloc[:split_idx]
+        val_df = df.iloc[split_idx:]
+
+        # Save back to JSONL
+        train_df.to_json(train_output, orient="records", lines=True, force_ascii=False)
+        val_df.to_json(val_output, orient="records", lines=True, force_ascii=False)
+
+        print(f"Saved {len(train_df)} samples to {train_output}")
+        print(f"Saved {len(val_df)} samples to {val_output}")
+        return
+    
+    # Shuffle
+    df = df.sample(frac=1, random_state=42).reset_index(drop=True)
+    
+    # --- Detect format ---
+    if "messages" in df.columns:
+        # Extract assistant content from messages
+        df["assistant_content"] = df["messages"].apply(get_assistant_content)
+    elif "text" in df.columns:
+        # Use raw text directly
+        df["assistant_content"] = df["text"]
+    elif "completion" in df.columns:
+        df["assistant_content"] = df["completion"]
+    elif "action" in df.columns:
+        df["assistant_content"] = df["action"]
+    else:
+        raise ValueError("Dataset must contain either 'messages' or 'text' column")
+
+    # Buckets by action
+    # For each action, filter rows where assistant_content contains it
+    buckets = {
+        k: df[df["assistant_content"].str.contains(k, na=False)]
+        for k in action_ratio.keys()
+    }
+
+    # Calculate target samples per action
+    total = sum(action_ratio.values())
+    targets = {k: int(action_ratio[k] / total * lines) for k in action_ratio}
+
+    # Collect balanced samples
+    selected_dfs = []
+    for action, bucket in buckets.items():
+        selected_dfs.append(bucket.sample(
+            n=min(len(bucket), targets[action]),
+            random_state=42
+        ))
+
+    # Merge and shuffle again
+    selected_df = pd.concat(selected_dfs).sample(frac=1, random_state=42).reset_index(drop=True)
+
+    # Trim to max_lines
+    selected_df = selected_df.head(lines)
+    print(len(selected_df))
+
+    # Train/val split
+    split_idx = int(len(selected_df) * train_ratio)
+    train_df = selected_df.iloc[:split_idx].drop(columns=["assistant_content"], errors="ignore")
+    val_df = selected_df.iloc[split_idx:].drop(columns=["assistant_content"], errors="ignore")
+
+    # Save back to JSONL
+    train_df.to_json(train_output, orient="records", lines=True, force_ascii=False)
+    val_df.to_json(val_output, orient="records", lines=True, force_ascii=False)
+
+    print(f"Saved {len(train_df)} samples to {train_output}")
+    print(f"Saved {len(val_df)} samples to {val_output}") 
+
+def get_assistant_content(messages):
+    for msg in messages:
+        if msg.get("role") == "assistant":
+            return msg.get("content", "")
+    return ""

llm/api.py

@@ -2,31 +2,43 @@ import re
 from typing import Dict, Optional
 from fastapi import FastAPI
 from pydantic import BaseModel
-from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers import BitsAndBytesConfig, AutoModelForCausalLM, AutoTokenizer
 from peft import PeftModel
 import uvicorn
+import torch
 
 base_model_id = "Qwen/Qwen2.5-0.5B-Instruct"
-lora_adapter_or_id = "qwen2.5-0.5b-instruct-sumobot"
-# lora_adapter_or_id = "adapters/qwen2.5_0.5b_lora"
+# base_model_id = "qwen2.5-0.5b-instruct-sumobot-merged"
+#lora_adapter_or_id = "qwen2.5-0.5b-instruct-sumobot"
+lora_adapter_or_id = "adapters/qwen2.5_0.5b_lora_half"
 
 # # Load tokenizer
-tokenizer = AutoTokenizer.from_pretrained(base_model_id)
+tokenizer = AutoTokenizer.from_pretrained(
+    base_model_id,
+    trust_remote_code=True, use_fast=True)
+
+bnb_config = BitsAndBytesConfig(
+    load_in_4bit=True,
+    bnb_4bit_use_double_quant=False,
+    bnb_4bit_quant_type="nf4",
+    bnb_4bit_compute_dtype=torch.bfloat16,
+)
 
 # Load base model
 base_model = AutoModelForCausalLM.from_pretrained(
     base_model_id,
-    device_map="auto",
-    torch_dtype="auto"
-)
+    device_map="auto",  
+    # quantization_config=bnb_config,
+    # torch_dtype=torch.bfloat16,
+    trust_remote_code=True )
 
-model, tokenizer = load(base_model_id)
 
 # Load LoRA weights
 model = PeftModel.from_pretrained(base_model, lora_adapter_or_id)
 
 # Merge LoRA into the base model (optional if you want a standalone model)
 model = model.merge_and_unload()
+# model.eval()
 
 import re
 from typing import Dict, Optional
@@ -60,14 +72,15 @@ def parse_action(output: str):
 
         actions[name] = duration
 
+    print(f"result: {actions}")
     return {"action": actions}
 
 
 def get_finetuned_action(query_state):
     # Inference with chat template
     messages = [
-        {"role": "system", "content": "You are a Sumobot assistant that decides actions based on game state."},
-        {"role": "user", "content": f"Given this game state: {query_state}"},
+        {"role": "system", "content": "You are a Sumobot assistant"},
+        {"role": "user", "content": f"State: {query_state}"},
     ]
 
     # Apply the tokenizer's built-in chat template
@@ -81,13 +94,9 @@ def get_finetuned_action(query_state):
 
     outputs = model.generate(
         **inputs,
-        max_new_tokens=128
+        max_new_tokens=15
     )
 
-    result = ""
-    for token in generate(model, tokenizer, chat_prompt, max_tokens=50):
-        result += token
-
     # Slice out only the newly generated tokens
     generated_tokens = outputs[0][inputs["input_ids"].shape[1]:]
 

llm/api_gguf.py

@@ -0,0 +1,213 @@
+"""
+Model Pool Sumobot API - Multiple model instances for true parallelism
+Requires more GPU memory but can process multiple requests simultaneously
+"""
+import re
+import asyncio
+from typing import Dict, Optional, List
+from fastapi import FastAPI
+from pydantic import BaseModel
+import uvicorn
+from llama_cpp import Llama
+import multiprocessing as mp
+from concurrent.futures import ProcessPoolExecutor
+
+# ==================== Configuration ====================
+MODEL_PATH = "models/qwen2.5-sumobot-half-q8_0.gguf"
+N_GPU_LAYERS = -1
+NUM_WORKERS = 20  # Number of parallel model instances
+
+ACTION_PATTERN = re.compile(r"^([A-Za-z]+)\s*([\d.]+)$")
+
+# ==================== Worker Process ====================
+class ModelWorker:
+    """Each worker has its own model instance"""
+    
+    def __init__(self):
+        self.model = None
+    
+    def initialize(self):
+        """Load model in worker process"""
+        if self.model is None:
+            print(f"Loading model in worker {mp.current_process().name}...")
+            self.model = Llama(
+                model_path=MODEL_PATH,
+                n_ctx=512,
+                n_threads=2,  # Fewer threads per worker
+                n_gpu_layers=N_GPU_LAYERS,
+                verbose=False,
+                n_batch=512,
+                use_mmap=True,
+            )
+            print(f"✅ Model loaded in {mp.current_process().name}")
+    
+    def parse_action(self, output: str) -> Dict[str, Optional[float]]:
+        """Parse model output to action dict"""
+        action_map = {
+            "SK": "Skill", "DS": "Dash", "FWD": "Accelerate",
+            "TL": "TurnLeft", "TR": "TurnRight",
+        }
+       
+        actions = {}
+        for part in output.split(","):
+            part = part.strip()
+            if not part:
+                continue
+           
+            name = part
+            duration = None
+           
+            match = ACTION_PATTERN.match(part)
+            if match:
+                name = match.group(1)
+                duration = float(match.group(2))
+           
+            name_upper = name.upper()
+            for short, full in action_map.items():
+                if name_upper.startswith(short):
+                    actions[full] = duration
+                    break
+       
+        return actions
+    
+    def process(self, state: str) -> dict:
+        """Process a single request"""
+        import time
+        
+        if self.model is None:
+            self.initialize()
+        
+        prompt = f"""<|im_start|>system
+Sumobot assistant.<|im_end|>
+<|im_start|>user
+{state}<|im_end|>
+<|im_start|>assistant
+action:"""
+       
+        start_time = time.time()
+       
+        output = self.model(
+            prompt,
+            max_tokens=50,
+            temperature=0.1,
+            stop=["<|im_end|>", "\n"],
+            top_p=0.95,
+            echo=False
+        )
+       
+        inference_time = (time.time() - start_time) * 1000
+        raw_output = output['choices'][0]['text'].strip()
+       
+        return {
+            "raw_output": raw_output,
+            "action": self.parse_action(raw_output),
+            "inference_time_ms": round(inference_time, 2),
+            "worker": mp.current_process().name
+        }
+
+# ==================== Global Worker Instance ====================
+_worker = ModelWorker()
+
+def process_request(state: str) -> dict:
+    """Global function for ProcessPoolExecutor"""
+    return _worker.process(state)
+
+# ==================== FastAPI ====================
+app = FastAPI()
+
+class QueryInput(BaseModel):
+    state: str
+
+# Process pool for parallel execution
+executor = None
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize process pool on startup"""
+    global executor
+    
+    print(f"🚀 Starting {NUM_WORKERS} model workers...")
+    executor = ProcessPoolExecutor(
+        max_workers=NUM_WORKERS,
+        mp_context=mp.get_context('spawn')
+    )
+    
+    # Warm up workers
+    print("🔥 Warming up workers...")
+    dummy_state = "BotPos=[0,0], BotRot=0, EnemyPos=[1,1], EnemyRot=0"
+    futures = [
+        executor.submit(process_request, dummy_state) 
+        for _ in range(NUM_WORKERS)
+    ]
+    for future in futures:
+        future.result()
+    
+    print(f"✅ {NUM_WORKERS} workers ready!\n")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Clean up process pool"""
+    global executor
+    if executor:
+        executor.shutdown(wait=True)
+
+@app.post("/query")
+async def query(input: QueryInput):
+    """
+    Process request using worker pool
+    Can handle NUM_WORKERS requests truly in parallel
+    """
+    try:
+        loop = asyncio.get_event_loop()
+        result = await loop.run_in_executor(
+            executor,
+            process_request,
+            input.state
+        )
+        return result
+    except Exception as e:
+        return {
+            "error": str(e),
+            "message": "Failed to process request"
+        }
+
+@app.get("/stats")
+async def stats():
+    """Get worker pool statistics"""
+    return {
+        "num_workers": NUM_WORKERS,
+        "model_path": MODEL_PATH,
+    }
+
+# ==================== Run ====================
+if __name__ == "__main__":
+    # Required for Windows multiprocessing
+    mp.set_start_method('spawn', force=True)
+    
+    print(f"🚀 Starting API with {NUM_WORKERS} parallel workers")
+    print("⚡ Can process multiple requests simultaneously\n")
+    
+    uvicorn.run(
+        app, 
+        host="0.0.0.0", 
+        port=8000,
+        workers=1,
+        log_level="warning"
+    )
+
+# ==================== Notes ====================
+"""
+MEMORY REQUIREMENTS:
+- Each worker loads a full model copy
+- Q4 model ~800MB × 4 workers = ~3.2GB VRAM minimum
+- Adjust NUM_WORKERS based on your GPU memory
+
+PERFORMANCE:
+- Queue-based (single model): ~50ms per request, sequential
+- Pool-based (4 models): ~50ms per request, but 4 in parallel
+- For 4 Unity clients @ 100ms interval: Pool is 4x faster
+
+When to use which:
+- Queue (single model): <3 concurrent clients, limited VRAM
+- Pool (multiple models): 3+ concurrent clients, enough VRAM
+"""

llm/api_mlx.py

@@ -27,9 +27,9 @@ def parse_action(output: str):
         duration = None
 
         direct_match = re.match(r"^([A-Za-z]+)\s*([\d.]+)$", part)
-            if direct_match:
-                name = direct_match.group(1).strip()
-                duration = float(direct_match.group(2))
+        if direct_match:
+            name = direct_match.group(1).strip()
+            duration = float(direct_match.group(2))
 
         # Normalize shorthand to full name
         for short, full in action_map.items():

llm/complete_dataset.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fc5b5d3a9b21f71d3d0737bee4ade72b71920ce430fc4e81a9e2ed483438d406
+size 325872710

llm/convert_to_gguf.py

@@ -0,0 +1,235 @@
+import os
+import subprocess
+import sys
+from pathlib import Path
+import shutil
+
+print("="*70)
+print("🪟 Windows GGUF Conversion for Qwen2.5 0.5B + LoRA")
+print("="*70)
+print()
+
+# ==================== Configuration ====================
+base_model_id = "Qwen/Qwen2.5-0.5B-Instruct"
+lora_adapter_path = "adapters/qwen2.5_0.5b_lora_half2"  # Your LoRA adapter folder
+
+# Output paths
+merged_model_path = "./merged_qwen2.5_sumobot_half2"
+gguf_output_dir = "./models"
+gguf_fp16_path = os.path.join(gguf_output_dir, "qwen2.5-sumobot-half-fp16.gguf")
+
+# ==================== Prerequisites Check ====================
+print("📋 Step 1: Checking prerequisites...")
+print("-"*70)
+
+
+# # ==================== Step 1: Merge LoRA with Base Model ====================
+# print("="*70)
+# print("📦 Step 2: Merging LoRA adapter with base model")
+# print("="*70)
+# print()
+
+# from transformers import AutoModelForCausalLM, AutoTokenizer
+# from peft import PeftModel
+# import torch
+
+# print(f"Loading base model: {base_model_id}")
+# tokenizer = AutoTokenizer.from_pretrained(base_model_id)
+# base_model = AutoModelForCausalLM.from_pretrained(
+#     base_model_id,
+#     # torch_dtype=torch.float16,
+#     device_map="auto",  # Keep on CPU for Windows compatibility
+#     trust_remote_code=True
+# )
+
+# print(f"Loading LoRA adapter: {lora_adapter_path}")
+# model = PeftModel.from_pretrained(base_model, lora_adapter_path)
+
+# print("Merging LoRA weights into base model...")
+# merged_model = model.merge_and_unload()
+
+# print(f"Saving merged model to: {merged_model_path}")
+# os.makedirs(merged_model_path, exist_ok=True)
+# merged_model.save_pretrained(merged_model_path, safe_serialization=True)
+# tokenizer.save_pretrained(merged_model_path)
+
+# print("✅ Merged model saved!")
+# print()
+
+# # ==================== Step 3: Convert to GGUF FP16 ====================
+# print("="*70)
+# print("🔄 Step 4: Converting to GGUF FP16 format")
+# print("="*70)
+# print()
+# from pathlib import Path
+
+# ROOT_DIR = Path(r"D:\sumobot")
+# SCRIPT_PATH = ROOT_DIR / "llama.cpp" / "convert_hf_to_gguf.py"
+
+# os.makedirs(gguf_output_dir, exist_ok=True)
+
+# if not SCRIPT_PATH.exists():
+#     print("❌ Conversion script not found!")
+#     print(f"Expected at: {SCRIPT_PATH}")
+#     sys.exit(1)
+
+# print(f"Converting to: {gguf_fp16_path}")
+# print("This may take a few minutes...")
+
+# try:
+#     subprocess.run([
+#         sys.executable,  # Use current Python interpreter
+#         str(SCRIPT_PATH),
+#         merged_model_path,
+#         "--outfile", gguf_fp16_path,
+#         "--outtype", "f16"
+#     ], check=True)
+    
+#     file_size = os.path.getsize(gguf_fp16_path) / (1024**2)
+#     print(f"✅ GGUF FP16 created: {file_size:.1f} MB")
+# except subprocess.CalledProcessError:
+#     print("❌ Conversion failed!")
+#     sys.exit(1)
+
+# print()
+
+# ==================== Step 4: Quantize to Different Formats ====================
+print("="*70)
+print("⚡ Step 5: Quantizing to different formats")
+print("="*70)
+print()
+
+from pathlib import Path
+
+ROOT_DIR = Path(r"D:\sumobot")
+SCRIPT_PATH = ROOT_DIR / "llama.cpp"
+
+# Find quantize executable on Windows
+quantize_exe = SCRIPT_PATH / "build" / "bin" / "Release" / "llama-quantize.exe"
+
+# if not quantize_exe.exists():
+#     # Try alternative paths
+#     alt_paths = [
+#         llama_cpp_path / "build" / "Release" / "llama-quantize.exe",
+#         llama_cpp_path / "build" / "bin" / "llama-quantize.exe",
+#     ]
+    
+#     for alt_path in alt_paths:
+#         if alt_path.exists():
+#             quantize_exe = alt_path
+#             break
+#     else:
+#         print("❌ llama-quantize.exe not found!")
+#         print("Build may have failed. Check build output above.")
+#         sys.exit(1)
+
+# print(f"Using quantize tool: {quantize_exe}")
+# print()
+
+# Quantization types
+quant_configs = {
+    "Q8_0": "Best quality (~50% compression)",
+    "Q5_K_M": "Balanced (recommended)",
+    "Q4_K_M": "Fast inference",
+    "Q4_0": "Fastest (good quality)",
+}
+
+quantized_models = {}
+
+for quant_type, description in quant_configs.items():
+    output_path = os.path.join(gguf_output_dir, f"qwen2.5-sumobot-half-{quant_type.lower()}.gguf")
+    
+    print(f"📦 Quantizing to {quant_type}...")
+    print(f"   {description}")
+    
+    try:
+        subprocess.run([
+            str(quantize_exe),
+            gguf_fp16_path,
+            output_path,
+            quant_type
+        ], check=True)
+        
+        size_mb = os.path.getsize(output_path) / (1024**2)
+        quantized_models[quant_type] = {
+            "path": output_path,
+            "size_mb": size_mb
+        }
+        print(f"   ✅ Created: {size_mb:.1f} MB")
+    except subprocess.CalledProcessError:
+        print(f"   ❌ Failed to create {quant_type}")
+    
+    print()
+
+# # ==================== Step 5: Test the Model ====================
+# print("="*70)
+# print("🧪 Step 6: Testing quantized model")
+# print("="*70)
+# print()
+
+# print("Installing llama-cpp-python for Windows...")
+# try:
+#     # Install with pip
+#     subprocess.run([
+#         sys.executable, "-m", "pip", "install", "llama-cpp-python"
+#     ], check=True)
+#     print("✅ llama-cpp-python installed")
+# except subprocess.CalledProcessError:
+#     print("⚠️ Could not install llama-cpp-python automatically")
+#     print("Install manually with: pip install llama-cpp-python")
+
+# print()
+
+# # Test with one of the quantized models
+# if quantized_models:
+#     print("Testing model inference...")
+    
+#     try:
+#         from llama_cpp import Llama
+        
+#         # Use Q5_K_M model for testing (good balance)
+#         test_model_path = quantized_models.get("Q5_K_M", list(quantized_models.values())[0])["path"]
+        
+#         print(f"Loading: {test_model_path}")
+#         llm = Llama(
+#             model_path=test_model_path,
+#             n_ctx=2048,
+#             n_threads=4,
+#             verbose=False
+#         )
+        
+#         # Test prompt
+#         test_state = "AngleToEnemy=7.77, AngleToEnemyScore=0.99, DistanceToEnemyScore=0.76, NearBorderArenaScore=0.11, FacingToArena=-0.32"
+#         prompt = f"sumobot state: {test_state}\naction:"
+        
+#         print(f"\nTest input: {test_state}")
+#         print("Generating action...\n")
+        
+#         import time
+#         start = time.time()
+        
+#         output = llm(
+#             prompt,
+#             max_tokens=50,
+#             temperature=0.1,
+#             stop=["<|endoftext|>", "\n\n"]
+#         )
+        
+#         elapsed = (time.time() - start) * 1000
+        
+#         generated = output['choices'][0]['text'].strip()
+#         print(f"Generated action: {generated}")
+#         print(f"⏱️ Inference time: {elapsed:.1f}ms")
+        
+#         if elapsed < 100:
+#             print("✅ Meets <100ms requirement!")
+#         else:
+#             print("⚠️ Slower than 100ms target")
+        
+#     except ImportError:
+#         print("⚠️ llama-cpp-python not available for testing")
+#         print("Install it later to test: pip install llama-cpp-python")
+#     except Exception as e:
+#         print(f"⚠️ Test failed: {e}")
+
+# print()

llm/dataset_prompt.py

@@ -0,0 +1,378 @@
+#!/usr/bin/env python3
+"""
+Parallel Batched LLM Inference for GGUF models
+Splits dataset into batches and processes them in parallel with multiple workers
+"""
+
+import json
+import os
+import multiprocessing as mp
+from tqdm import tqdm
+from pathlib import Path
+
+def count_lines(filename):
+    """Count total lines in a file"""
+    count = 0
+    try:
+        with open(filename, 'r') as f:
+            for _ in f:
+                count += 1
+    except:
+        pass
+    return count
+
+def split_files_into_batches(input_files, num_batches, temp_dir="./batches"):
+    """
+    Split multiple input files into batch files
+    
+    Args:
+        input_files: List of input files
+        num_batches: Number of batches to create
+        temp_dir: Directory to store batch files
+    
+    Returns:
+        List of batch file paths
+    """
+    print("=" * 70)
+    print("STEP 1: Splitting files into batches")
+    print("=" * 70)
+    
+    # Create temp directory
+    os.makedirs(temp_dir, exist_ok=True)
+    
+    # Count total lines
+    print("\nCounting total lines...")
+    total_lines = 0
+    for input_file in input_files:
+        lines = count_lines(input_file)
+        total_lines += lines
+        print(f"  {input_file}: {lines:,} lines")
+    
+    print(f"\nTotal lines: {total_lines:,}")
+    
+    if total_lines == 0:
+        print("✗ No data found in input files!")
+        return []
+    
+    # Calculate lines per batch
+    lines_per_batch = total_lines // num_batches
+    remainder = total_lines % num_batches
+    
+    print(f"Lines per batch: ~{lines_per_batch:,}")
+    print(f"Creating {num_batches} batch files...\n")
+    
+    # Create batch files
+    batch_files = []
+    current_batch = 0
+    current_batch_lines = 0
+    current_batch_file = None
+    
+    for input_file in input_files:
+        print(f"Processing {input_file}...")
+        
+        try:
+            with open(input_file, 'r') as infile:
+                for line in tqdm(infile, desc="  Splitting"):
+                    line = line.strip()
+                    if not line:
+                        continue
+                    
+                    # Open new batch file if needed
+                    if current_batch_file is None or current_batch_lines >= lines_per_batch:
+                        # Close previous batch file
+                        if current_batch_file is not None:
+                            current_batch_file.close()
+                        
+                        # Open new batch file
+                        if current_batch < num_batches:
+                            batch_path = os.path.join(temp_dir, f"batch_{current_batch:04d}.jsonl")
+                            batch_files.append(batch_path)
+                            current_batch_file = open(batch_path, 'w')
+                            current_batch += 1
+                            current_batch_lines = 0
+                    
+                    # Write line to current batch
+                    if current_batch_file is not None:
+                        current_batch_file.write(line + '\n')
+                        current_batch_lines += 1
+        
+        except FileNotFoundError:
+            print(f"  ✗ File not found: {input_file}")
+            continue
+        except Exception as e:
+            print(f"  ✗ Error: {e}")
+            continue
+    
+    # Close last batch file
+    if current_batch_file is not None:
+        current_batch_file.close()
+    
+    print(f"\n✓ Created {len(batch_files)} batch files in {temp_dir}/\n")
+    
+    return batch_files
+
+def worker_process(worker_id, batch_file, output_file, model_path, config):
+    """
+    Worker process that runs inference on one batch
+    
+    Args:
+        worker_id: ID of this worker
+        batch_file: Input batch file path
+        output_file: Output file path for this batch
+        model_path: Path to GGUF model
+        config: Configuration dict
+    """
+    try:
+        from llama_cpp import Llama
+        
+        # Load model
+        print(f"[Worker {worker_id}] Loading model...")
+        llm = Llama(
+            model_path=model_path,
+            n_ctx=config.get('n_ctx', 512),
+            n_threads=config.get('n_threads', 4),
+            n_gpu_layers=config.get('n_gpu_layers', 0),
+            verbose=False
+        )
+        
+        print(f"[Worker {worker_id}] Model loaded. Processing {batch_file}...")
+        
+        # Process batch
+        processed = 0
+        skipped = 0
+        
+        with open(batch_file, 'r') as infile, open(output_file, 'w') as outfile:
+            for line in infile:
+                line = line.strip()
+                if not line:
+                    continue
+                
+                try:
+                    data = json.loads(line)
+                    state = data.get('state', '')
+                    existing_action = data.get('action', '')
+                    
+                    
+                    prompt = f"""<|im_start|>system
+Sumobot assistant.<|im_end|>
+<|im_start|>user
+{state}<|im_end|>
+<|im_start|>assistant
+action:"""
+                    
+                    output = llm(
+                        prompt,
+                        max_tokens=config.get('max_tokens', 32),
+                        temperature=config.get('temperature', 0.1),
+                        stop=["<|im_end|>", "\n"],
+                        echo=False,
+                        top_p=config.get('top_p', 0.95),
+                    )
+                    
+                    action = output['choices'][0]['text'].strip()
+                    
+                    result = {
+                        "state": state,
+                        "action": action
+                    }
+                    processed += 1
+                    
+                    # Write result
+                    outfile.write(json.dumps(result) + '\n')
+                    
+                    # Progress update
+                    if (processed + skipped) % 100 == 0:
+                        outfile.flush()
+                
+                except Exception as e:
+                    print(f"[Worker {worker_id}] Error processing line: {e}")
+                    continue
+        
+        print(f"[Worker {worker_id}] ✓ Completed! Processed: {processed:,}, Skipped: {skipped:,}")
+        return processed, skipped
+    
+    except Exception as e:
+        print(f"[Worker {worker_id}] ✗ Fatal error: {e}")
+        return 0, 0
+
+def merge_batch_outputs(batch_output_files, final_output_file):
+    """
+    Merge all batch output files into final output
+    
+    Args:
+        batch_output_files: List of batch output files
+        final_output_file: Final merged output file
+    """
+    print("\n" + "=" * 70)
+    print("STEP 3: Merging batch results")
+    print("=" * 70)
+    
+    total_lines = 0
+    
+    with open(final_output_file, 'w') as outfile:
+        for batch_file in batch_output_files:
+            if not os.path.exists(batch_file):
+                print(f"  ✗ Batch output not found: {batch_file}")
+                continue
+            
+            lines = 0
+            with open(batch_file, 'r') as infile:
+                for line in infile:
+                    outfile.write(line)
+                    lines += 1
+            
+            total_lines += lines
+            print(f"  ✓ Merged {batch_file}: {lines:,} lines")
+    
+    print(f"\n✓ Final output: {final_output_file}")
+    print(f"  Total lines: {total_lines:,}\n")
+
+def run_parallel_inference(input_files, output_file, model_path, num_batches=10, config=None):
+    """
+    Main function to run parallel batched inference
+    
+    Args:
+        input_files: List of input JSONL files
+        output_file: Final output file
+        model_path: Path to GGUF model
+        num_batches: Number of parallel batches
+        config: Model configuration dict
+    """
+    if config is None:
+        config = {
+            'n_ctx': 512,
+            'n_threads': 4,
+            'n_gpu_layers': 0,
+            'max_tokens': 32,
+            'temperature': 0.1
+        }
+    
+    print("\n" + "=" * 70)
+    print("PARALLEL BATCHED INFERENCE")
+    print("=" * 70)
+    print(f"Model: {model_path}")
+    print(f"Number of batches: {num_batches}")
+    print(f"Input files: {len(input_files)}")
+    print(f"Output: {output_file}")
+    print("=" * 70 + "\n")
+    
+    # Create directories
+    temp_dir = "./batches"
+    output_dir = "./batch_outputs"
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Step 1: Split into batches
+    batch_files = split_files_into_batches(input_files, num_batches, temp_dir)
+    
+    if not batch_files:
+        print("✗ No batches created!")
+        return
+    
+    # Step 2: Run parallel inference
+    print("=" * 70)
+    print("STEP 2: Running parallel inference")
+    print("=" * 70)
+    print(f"Starting {len(batch_files)} worker processes...\n")
+    
+    # Create output file paths
+    batch_output_files = [
+        os.path.join(output_dir, f"output_{i:04d}.jsonl")
+        for i in range(len(batch_files))
+    ]
+    
+    # Create worker arguments
+    worker_args = [
+        (i, batch_files[i], batch_output_files[i], model_path, config)
+        for i in range(len(batch_files))
+    ]
+    
+    # Run workers in parallel
+    with mp.Pool(processes=len(batch_files)) as pool:
+        results = pool.starmap(worker_process, worker_args)
+    
+    # Summary
+    total_processed = sum(r[0] for r in results)
+    total_skipped = sum(r[1] for r in results)
+    
+    print("\n" + "=" * 70)
+    print("Parallel inference completed!")
+    print(f"  New inferences: {total_processed:,}")
+    print(f"  Kept existing: {total_skipped:,}")
+    print(f"  Total: {total_processed + total_skipped:,}")
+    print("=" * 70)
+    
+    # Step 3: Merge outputs
+    merge_batch_outputs(batch_output_files, output_file)
+    
+    # Cleanup option
+    print("\nCleanup temporary files?")
+    response = input("Delete batch files and outputs? (y/n): ")
+    if response.lower() == 'y':
+        import shutil
+        try:
+            shutil.rmtree(temp_dir)
+            shutil.rmtree(output_dir)
+            print("✓ Temporary files deleted")
+        except Exception as e:
+            print(f"✗ Error deleting temp files: {e}")
+    
+    print("\n" + "=" * 70)
+    print("ALL DONE!")
+    print("=" * 70)
+    print(f"Final output: {output_file}")
+    print("=" * 70 + "\n")
+
+
+if __name__ == "__main__":
+    
+    # ========================================
+    # CONFIGURATION
+    # ========================================
+    
+    # Path to your GGUF model
+    model_path = "models/qwen2.5-sumobot-half-fp16.gguf"
+    
+    # Input files to process
+    input_files = [
+        "../dataset/temp.jsonl",                    # Original dataset
+        "new_states_to_infer.jsonl",   # New states
+    ]
+    
+    # Output file
+    output_file = "complete_dataset.jsonl"
+    
+    # Number of parallel batches
+    num_batches = 10
+    
+    # Model configuration
+    config = {
+        'n_ctx': 512,           # Context size
+        'n_threads': 4,         # Threads per worker
+        'n_gpu_layers': -1,      # GPU layers (0 = CPU only, 35+ = full GPU)
+        'max_tokens': 32,       # Max tokens to generate
+        'top_p': 0.95
+    }
+    
+    # ========================================
+    # RUN
+    # ========================================
+    
+    print("\nConfiguration:")
+    print(f"  Model: {model_path}")
+    print(f"  Batches: {num_batches}")
+    print(f"  Threads per worker: {config['n_threads']}")
+    print(f"  GPU layers: {config['n_gpu_layers']}")
+    print(f"  Input files: {input_files}")
+    print(f"  Output: {output_file}")
+    
+    response = input("\nProceed? (y/n): ")
+    if response.lower() == 'y':
+        run_parallel_inference(
+            input_files=input_files,
+            output_file=output_file,
+            model_path=model_path,
+            num_batches=num_batches,
+            config=config
+        )
+    else:
+        print("Cancelled.")

llm/expand_dataset.py

@@ -0,0 +1,159 @@
+import json
+import numpy as np
+from itertools import product
+from tqdm import tqdm
+
+def load_existing_states(filename):
+    """Load existing states from the dataset file"""
+    existing_states = set()
+    
+    print(f"Loading existing states from {filename}...")
+    try:
+        with open(filename, 'r') as f:
+            for line in tqdm(f, desc="Reading existing data"):
+                line = line.strip()
+                if line:
+                    data = json.loads(line)
+                    state = data['state']
+                    existing_states.add(state)
+    except FileNotFoundError:
+        print(f"File {filename} not found. Will create new file.")
+    
+    print(f"Loaded {len(existing_states)} existing states")
+    return existing_states
+
+def parse_state_to_key(state_str):
+    """Convert state string to a normalized key for comparison"""
+    # Extract values from state string
+    parts = state_str.split(', ')
+    values = {}
+    for part in parts:
+        key, value = part.split('=')
+        values[key] = float(value.rstrip('.'))
+    
+    # Create normalized key with rounded values to handle floating point precision
+    key = (
+        round(values['AngleToEnemy'], 2),
+        round(values['AngleToEnemyScore'], 2),
+        round(values['DistanceToEnemyScore'], 2),
+        round(values['NearBorderArenaScore'], 2),
+        round(values['FacingToArena'], 2)
+    )
+    return key
+
+def create_state_string(angle, angle_score, distance_score, border_score, facing):
+    """Create state string from parameters"""
+    return f"AngleToEnemy={angle:.2f}, AngleToEnemyScore={angle_score:.2f}, DistanceToEnemyScore={distance_score:.2f}, NearBorderArenaScore={border_score:.2f}, FacingToArena={facing:.2f}."
+
+def generate_new_states(existing_states):
+    """Generate all possible state combinations that don't exist in the dataset"""
+    
+    # Define parameter ranges based on requirements
+    angle_to_enemy = np.arange(-180, 181, 1)  # -180 to 180, step 1
+    angle_to_enemy_score = np.arange(0, 1.01, 0.2)  # 0 to 1, step 0.2
+    distance_to_enemy_score = np.arange(0, 1.01, 0.2)  # 0 to 1, step 0.2
+    near_border_arena_score = np.arange(0, 1.01, 0.2)  # 0 to 1, step 0.2
+    facing_to_arena = np.arange(-1, 1.01, 0.2)  # -1 to 1, step 0.2
+    
+    # Round to avoid floating point precision issues
+    angle_to_enemy_score = np.round(angle_to_enemy_score, 2)
+    distance_to_enemy_score = np.round(distance_to_enemy_score, 2)
+    near_border_arena_score = np.round(near_border_arena_score, 2)
+    facing_to_arena = np.round(facing_to_arena, 2)
+    
+    print("\nParameter ranges:")
+    print(f"AngleToEnemy: {len(angle_to_enemy)} values (from -180 to 180)")
+    print(f"AngleToEnemyScore: {len(angle_to_enemy_score)} values ({angle_to_enemy_score})")
+    print(f"DistanceToEnemyScore: {len(distance_to_enemy_score)} values ({distance_to_enemy_score})")
+    print(f"NearBorderArenaScore: {len(near_border_arena_score)} values ({near_border_arena_score})")
+    print(f"FacingToArena: {len(facing_to_arena)} values ({facing_to_arena})")
+    
+    total_combinations = (len(angle_to_enemy) * len(angle_to_enemy_score) * 
+                         len(distance_to_enemy_score) * len(near_border_arena_score) * 
+                         len(facing_to_arena))
+    print(f"\nTotal possible combinations: {total_combinations:,}")
+    
+    # Parse existing states into keys
+    print("\nParsing existing states...")
+    existing_keys = set()
+    for state_str in tqdm(existing_states, desc="Parsing states"):
+        try:
+            key = parse_state_to_key(state_str)
+            existing_keys.add(key)
+        except:
+            continue
+    
+    print(f"Parsed {len(existing_keys)} existing state keys")
+    
+    # Generate new states
+    new_states = []
+    print("\nGenerating new state combinations...")
+    
+    for angle, angle_score, dist_score, border_score, facing in tqdm(
+        product(angle_to_enemy, angle_to_enemy_score, distance_to_enemy_score, 
+                near_border_arena_score, facing_to_arena),
+        total=total_combinations,
+        desc="Checking combinations"
+    ):
+        # Create key for this combination
+        key = (
+            round(float(angle), 2),
+            round(float(angle_score), 2),
+            round(float(dist_score), 2),
+            round(float(border_score), 2),
+            round(float(facing), 2)
+        )
+        
+        # Check if this combination already exists
+        if key not in existing_keys:
+            state_str = create_state_string(angle, angle_score, dist_score, border_score, facing)
+            new_states.append(state_str)
+    
+    print(f"\nFound {len(new_states)} new state combinations to generate")
+    return new_states
+
+def save_new_states(new_states, output_filename):
+    """Save new states to file with placeholder actions"""
+    print(f"\nSaving new states to {output_filename}...")
+    
+    with open(output_filename, 'w') as f:
+        for state in tqdm(new_states, desc="Writing new states"):
+            # Placeholder action - will be filled by LLM inference
+            entry = {
+                "state": state,
+                "action": "PENDING"
+            }
+            f.write(json.dumps(entry) + '\n')
+    
+    print(f"Saved {len(new_states)} new states to {output_filename}")
+
+def main():
+    input_filename = "../dataset/temp.jsonl"
+    output_filename = "new_states_to_infer.jsonl"
+    
+    print("=" * 60)
+    print("Sumobot Dataset Expansion Script")
+    print("=" * 60)
+    
+    # Load existing states
+    existing_states = load_existing_states(input_filename)
+    
+    # Generate new states
+    new_states = generate_new_states(existing_states)
+    
+    # Save new states
+    if new_states:
+        save_new_states(new_states, output_filename)
+        print("\n" + "=" * 60)
+        print(f"SUCCESS! Generated {len(new_states):,} new states")
+        print(f"Output file: {output_filename}")
+        print("=" * 60)
+        print("\nNext steps:")
+        print("1. Run inference on these new states with your fine-tuned LLM")
+        print("2. Merge the results back with temp.json")
+        print("3. Use the complete dataset for vector database")
+    else:
+        print("\nNo new states to generate - dataset already complete!")
+
+if __name__ == "__main__":
+    main()

llm/testng.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+# coding: utf-8
+"""
+Simple inference - outputs exactly what the model generates
+"""
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import PeftModel
+
+model_name = "Qwen/Qwen2.5-0.5B-Instruct"
+adapter_folder_name = "adapters/qwen2.5_0.5b_lora_test"
+
+print("Loading model...")
+tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    device_map="auto",
+    # torch_dtype=torch.bfloat16,
+    trust_remote_code=True
+)
+model = PeftModel.from_pretrained(model, adapter_folder_name)
+model = model.merge_and_unload()
+model.eval()
+print("✅ Model loaded!\n")
+
+def get_action(state_string):
+    """Generate action - output exactly what model produces"""
+    # Format with ChatML template
+    prompt = f"""<|im_start|>system
+You are a Sumobot assistant.<|im_end|>
+<|im_start|>user
+sumobot state: {state_string}<|im_end|>
+<|im_start|>assistant
+action:"""
+
+    print(f"Test state: {state_string}\n")
+    print("Generating action...")
+
+    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+
+    with torch.no_grad():
+        outputs = model.generate(
+            input_ids=inputs["input_ids"],
+            attention_mask=inputs["attention_mask"],
+            max_new_tokens=50,
+            pad_token_id=tokenizer.eos_token_id,
+            temperature=0.1,
+            do_sample=True
+        )
+    
+    # with torch.no_grad():
+    #     outputs = model.generate(
+    #         **inputs,
+    #         max_new_tokens=50,
+    #         temperature=0.1,
+    #         do_sample=True,
+    #         pad_token_id=tokenizer.eos_token_id,
+    #     )
+    
+    # Decode and return AS-IS
+    result = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    return result
+
+# Test
+state = "AngleToEnemy=-44.41, AngleToEnemyScore=0.71, DistanceToEnemyScore=0.59, NearBorderArenaScore=0.40, FacingToArena=-0.71."
+
+print("Input:")
+print(state)
+print("\nRaw Model Output:")
+print(get_action(state))

llm/train_llm.ipynb

@@ -29,32 +29,45 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "id": "360596e1",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Set GPU max to 80%\n"
+     ]
+    }
+   ],
    "source": [
-    "import sys, os\n",
+    "import sys, os, torch\n",
     "sys.path.append(os.path.abspath(\"..\"))\n",
     "\n",
-    "from dataset_helper import export_dataset, get_dataset, get_dataset_dir\n",
+    "from dataset_helper import export_dataset,sample_dataset, get_dataset, get_dataset_dir\n",
+    "\n",
+    "if torch.cuda.is_available():\n",
+    "    print(\"Set GPU max to 80%\")\n",
+    "    torch.cuda.set_per_process_memory_fraction(0.8, device=0)\n",
     "\n",
     "# Amount of dataset lines that will be compiled and converted to dataset.jsonl.\n",
     "# If -1, use all lines.\n",
-    "max_dataset=10_000\n",
-    "# max_dataset=-1    # Use all lines\n",
+    "# max_dataset=100_000\n",
+    "max_dataset=1_200_000    # Use all lines\n",
     "train_validation_ratio=0.9\n",
     "\n",
     "# Training args\n",
-    "batches_per_device=4   # adjust based on GPU CUDA / MPS power. Using standard laptop RAM is suggested to set 1. Example (1,2,4,8)\n",
-    "# batches_per_device=8\n",
-    "num_train_epoch=2       # num train 2-3 is enough\n",
-    "gradient_accumulation=12\n",
-    "eval_accumulation=1\n",
+    "train_batches_per_device=2   # adjust based on GPU CUDA / MPS power. Using standard laptop RAM is suggested to set 1. Example (1,2,4,8)\n",
+    "val_batches_per_device=2   # adjust based on GPU CUDA / MPS power. Using standard laptop RAM is suggested to set 1. Example (1,2,4,8)\n",
+    "# batches_per_device=6\n",
+    "num_train_epoch=1       # num train 2-3 is enough\n",
+    "gradient_accumulation=2\n",
+    "eval_accumulation=2\n",
     "learning_rate=5e-5\n",
-    "save_every=0.5          #ratio\n",
-    "log_every=10\n",
-    "eval_ratio=20         #ratio\n",
+    "save_ratio=0.25          \n",
+    "log_ratio=0.1\n",
+    "eval_ratio=0.25         #ratio\n",
     "\n",
     "# LoRA\n",
     "rank=32\n",
@@ -63,7 +76,7 @@
     "\n",
     "model_name = \"Qwen/Qwen2.5-0.5B-Instruct\"\n",
     "\n",
-    "adapter_folder_name=\"adapters/qwen2.5_0.5b_lora\"\n",
+    "adapter_folder_name=\"adapters/qwen2.5_0.5b_lora_half\"\n",
     "dataset_train_output_path = f\"{get_dataset_dir()}/llm_dataset_train.jsonl\"\n",
     "dataset_val_output_path = f\"{get_dataset_dir()}/llm_dataset_val.jsonl\""
    ]
@@ -71,51 +84,71 @@
   {
    "cell_type": "markdown",
    "id": "ba6031ad",
-   "metadata": {},
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
    "source": [
     "# Load Data"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "id": "e0912c9b",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading local dataset from: ../dataset\n",
+      "Merged shape: (2363180, 52)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 1200000/1200000 [00:56<00:00, 21205.19it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1200000\n",
+      "1047340\n",
+      "Saved 942606 samples to ../dataset/llm_dataset_train.jsonl\n",
+      "Saved 104734 samples to ../dataset/llm_dataset_val.jsonl\n"
+     ]
+    }
+   ],
    "source": [
     "from sklearn.model_selection import train_test_split\n",
     "\n",
     "# Load data\n",
-    "df, dir = get_dataset()\n",
+    "df, dir = get_dataset(inside_arena=True)\n",
+    "temp_dir=f\"{get_dataset_dir()}/temp.jsonl\"\n",
     "\n",
-    "if max_dataset>-1:\n",
-    "    df = df.sample(max_dataset)\n",
+    "df = df.sample(max_dataset)\n",
+    "export_dataset(df, temp_dir, format=\"state_action\", completion_mode=\"short\", include_pos_rot=False)\n",
     "\n",
-    "df_train, df_val = train_test_split(\n",
-    "    df,\n",
-    "    train_size=train_validation_ratio,\n",
-    "    random_state=42,\n",
-    "    shuffle=True\n",
-    ")\n",
+    "action_ratio = {\n",
+    "    \"TL\": 0.35,\n",
+    "    \"TR\": 0.35,\n",
+    "    \"FWD\": 0.2,\n",
+    "    \"DS\": 0.05,\n",
+    "    \"SK\": 0.05,\n",
+    "}\n",
     "\n",
-    "export_dataset(\n",
-    "    df,\n",
-    "    dataset_train_output_path,\n",
-    "    format=\"jsonl_message\",\n",
-    "    completion_mode=\"short\",\n",
-    "    include_pos_rot=False\n",
-    ")\n",
-    "\n",
-    "export_dataset(\n",
-    "    df_val,\n",
+    "sample_dataset(\n",
+    "    temp_dir,\n",
+    "    dataset_train_output_path, \n",
     "    dataset_val_output_path,\n",
-    "    format=\"jsonl_message\",\n",
-    "    completion_mode=\"short\",\n",
-    "    include_pos_rot=False\n",
-    ")\n",
-    "\n",
-    "print(f\"Saved {len(df_train)} samples to {dataset_train_output_path}\")\n",
-    "print(f\"Saved {len(df_val)} samples to {dataset_val_output_path}\")"
+    "    max_dataset,\n",
+    "    action_ratio,\n",
+    "    train_validation_ratio,\n",
+    "    )"
    ]
   },
   {
@@ -151,7 +184,8 @@
      ]
     },
     "id": "2wUC3mmi5tYQ",
-    "outputId": "42ede229-d242-40f4-9b00-4adc953040ec"
+    "outputId": "42ede229-d242-40f4-9b00-4adc953040ec",
+    "scrolled": true
    },
    "outputs": [],
    "source": [
@@ -159,9 +193,12 @@
     "import json\n",
     "import torch\n",
     "from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, DataCollatorForLanguageModeling\n",
-    "from datasets import load_dataset\n",
+    "from datasets import load_dataset, load_from_disk\n",
     "from peft import LoraConfig, TaskType\n",
     "from trl import SFTTrainer\n",
+    "import gc\n",
+    "\n",
+    "gc.collect()\n",
     "\n",
     "# Device detection (MPS/CUDA)\n",
     "if torch.backends.mps.is_available():\n",
@@ -170,6 +207,9 @@
     "elif torch.cuda.is_available():\n",
     "    device = torch.device(\"cuda\")\n",
     "    device_map = {\"\": \"cuda\"}\n",
+    "    with torch.no_grad():\n",
+    "        torch.cuda.empty_cache()\n",
+    "        torch.cuda.ipc_collect()\n",
     "else:\n",
     "    device = torch.device(\"cpu\")\n",
     "    device_map = {\"\": \"cpu\"}\n",
@@ -183,8 +223,8 @@
     ")\n",
     "\n",
     "# Ensure padding token exists\n",
-    "if tokenizer.pad_token is None:\n",
-    "    tokenizer.add_special_tokens({'pad_token': tokenizer.eos_token})\n",
+    "tokenizer.pad_token = tokenizer.eos_token\n",
+    "tokenizer.padding_side = \"left\"\n",
     "\n",
     "model = AutoModelForCausalLM.from_pretrained(\n",
     "    model_name,\n",
@@ -197,7 +237,7 @@
     "lora_config = LoraConfig(\n",
     "    r=rank,\n",
     "    lora_alpha=alpha,\n",
-    "    target_modules=[\"q_proj\", \"v_proj\"],\n",
+    "    target_modules=[\"q_proj\", \"k_proj\", \"v_proj\", \"o_proj\", \"gate_proj\", \"up_proj\", \"down_proj\"],\n",
     "    lora_dropout=dropout,\n",
     "    bias=\"none\",\n",
     "    task_type=TaskType.CAUSAL_LM,\n",
@@ -224,22 +264,34 @@
     "        text,\n",
     "        truncation=True,\n",
     "        padding=\"max_length\",\n",
-    "        max_length=512  # adjust depending on context size\n",
+    "        max_length=256\n",
     "    )\n",
     "    tokenized[\"labels\"] = tokenized[\"input_ids\"].copy()\n",
     "    return tokenized\n",
     "\n",
     "\n",
     "# Tokenize train\n",
-    "tokenized_datasets = dataset.map(\n",
-    "    tokenize,\n",
-    "    batched=False\n",
-    ")\n",
+    "tokenized_path = \"tokenized_dataset\"\n",
+    "\n",
+    "if os.path.exists(tokenized_path):\n",
+    "    print(f\"📂 Loading existing tokenized dataset from: {tokenized_path}\")\n",
+    "    tokenized_datasets = load_from_disk(tokenized_path)\n",
+    "else:\n",
+    "    print(\"⚙️ Tokenizing dataset...\")\n",
+    "    tokenized_datasets = dataset.map(\n",
+    "        tokenize,\n",
+    "        batched=False,\n",
+    "        desc=\"Tokenizing dataset\"\n",
+    "    )\n",
+    "\n",
+    "    print(f\"💾 Saving tokenized dataset to: {tokenized_path}\")\n",
+    "    tokenized_datasets.save_to_disk(tokenized_path)\n",
     "\n",
     "# Training setup\n",
     "training_args = TrainingArguments(\n",
     "    output_dir=adapter_folder_name,\n",
-    "    per_device_train_batch_size=batches_per_device,\n",
+    "    per_device_train_batch_size=train_batches_per_device,\n",
+    "    per_device_eval_batch_size=val_batches_per_device,\n",
     "    gradient_accumulation_steps=gradient_accumulation,\n",
     "    eval_accumulation_steps=eval_accumulation,\n",
     "    learning_rate=learning_rate,\n",
@@ -269,8 +321,20 @@
     "    data_collator=data_collator\n",
     ")\n",
     "\n",
+    "# Enable resume ckpt\n",
+    "latest_ckpt = None\n",
+    "if os.path.isdir(adapter_folder_name):\n",
+    "    checkpoints = [os.path.join(adapter_folder_name, d) for d in os.listdir(adapter_folder_name) if d.startswith(\"checkpoint-\")]\n",
+    "    if checkpoints:\n",
+    "        latest_ckpt = max(checkpoints, key=lambda x: int(x.split(\"-\")[-1]))\n",
+    "\n",
+    "print(\"Resuming from:\", latest_ckpt)\n",
+    "\n",
     "# Train\n",
-    "trainer.train()\n",
+    "if latest_ckpt:\n",
+    "    trainer.train(resume_from_checkpoint=latest_ckpt)\n",
+    "else:\n",
+    "    trainer.train()\n",
     "\n",
     "# Save LoRA adapter + tokenizer\n",
     "trainer.model.save_pretrained(adapter_folder_name)\n",
@@ -280,7 +344,9 @@
   {
    "cell_type": "markdown",
    "id": "cfd63a56",
-   "metadata": {},
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
    "source": [
     "# Testing"
    ]
@@ -305,8 +371,16 @@
     "    torch_dtype=\"auto\"\n",
     ")\n",
     "\n",
+    "latest_ckpt = None\n",
+    "if os.path.isdir(adapter_folder_name):\n",
+    "    checkpoints = [os.path.join(adapter_folder_name, d) for d in os.listdir(adapter_folder_name) if d.startswith(\"checkpoint-\")]\n",
+    "    if checkpoints:\n",
+    "        latest_ckpt = max(checkpoints, key=lambda x: int(x.split(\"-\")[-1]))\n",
+    "\n",
+    "print(\"Resuming from:\", latest_ckpt)\n",
+    "\n",
     "# Load LoRA adapter\n",
-    "model = PeftModel.from_pretrained(model, adapter_folder_name)\n",
+    "model = PeftModel.from_pretrained(model, latest_ckpt)\n",
     "\n",
     "# Merge LoRA into the base model (optional if you want a standalone model)\n",
     "model = model.merge_and_unload()\n",
@@ -337,7 +411,9 @@
   {
    "cell_type": "markdown",
    "id": "05789a5e",
-   "metadata": {},
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
    "source": [
     "# Save merged model - OPTIONAL"
    ]
@@ -383,7 +459,7 @@
    "provenance": []
   },
   "kernelspec": {
-   "display_name": "ml",
+   "display_name": "venv",
    "language": "python",
    "name": "python3"
   },
@@ -397,7 +473,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.16"
+   "version": "3.12.10"
   },
   "widgets": {
    "application/vnd.jupyter.widget-state+json": {

llm/train_llm.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+import sys, os, torch
+sys.path.append(os.path.abspath(".."))
+
+from dataset_helper import export_dataset, get_dataset, get_dataset_dir
+
+if torch.cuda.is_available():
+    print("Set GPU max to 80%")
+    # torch.cuda.set_per_process_memory_fraction(0.8, device=0)
+
+
+# Amount of dataset lines that will be compiled and converted to dataset.jsonl.
+max_dataset=1_200_000
+train_validation_ratio=0.9
+
+# Training args - FIXED FOR RAM CONSTRAINTS
+train_batches_per_device=8    # REDUCED from 16 - critical for RAM
+val_batches_per_device=8      # REDUCED from 2
+gradient_accumulation=8      # INCREASED to maintain effective batch size
+eval_accumulation=8
+num_train_epoch=1
+learning_rate=5e-5
+save_ratio=0.01          
+log_ratio=0.005
+eval_ratio=0.25       
+
+# LoRA
+rank=32
+alpha=64
+dropout=0.01
+
+model_name = "Qwen/Qwen2.5-0.5B-Instruct"
+
+adapter_folder_name="adapters/qwen2.5_0.5b_lora_half2"
+dataset_train_output_path = f"{get_dataset_dir()}/llm_dataset_train.jsonl"
+dataset_val_output_path = f"{get_dataset_dir()}/llm_dataset_val.jsonl"
+# os.environ["OMP_NUM_THREADS"] = "8"
+# os.environ["MKL_NUM_THREADS"] = "8"  
+# os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+
+from functools import partial
+import json
+import torch
+from transformers import TrainerCallback, BitsAndBytesConfig, AutoTokenizer, AutoModelForCausalLM, TrainingArguments, DataCollatorForLanguageModeling
+from datasets import load_dataset, load_from_disk
+from peft import LoraConfig, TaskType
+from trl import SFTTrainer
+import gc
+from torch.utils.data import DataLoader
+
+# Device detection
+if torch.backends.mps.is_available():
+    device = torch.device("mps")
+    device_map = {"": "mps"}
+elif torch.cuda.is_available():
+    device = torch.device("cuda")
+    device_map = {"": device}
+    print(device_map)
+else:
+    device = torch.device("cpu")
+    device_map = {"": "cpu"}
+
+print(f"Using device: {device}")
+
+# FIXED: Proper config for 4-bit quantization
+# bnb_config = BitsAndBytesConfig(
+#     load_in_4bit=True,
+#     bnb_4bit_use_double_quant=True,  # Changed to True for better memory efficiency
+#     bnb_4bit_quant_type="nf4",
+#     bnb_4bit_compute_dtype=torch.bfloat16,
+# )
+
+# Load Qwen2.5-0.5B model & tokenizer
+tokenizer = AutoTokenizer.from_pretrained(
+    model_name,
+    trust_remote_code=True,
+    # use_fast=True
+)
+
+# Ensure padding token exists
+if tokenizer.pad_token is None:
+    tokenizer.add_special_tokens({'pad_token': tokenizer.eos_token})
+
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    # quantization_config=bnb_config,   
+    device_map="auto",  
+    torch_dtype=torch.bfloat16,
+    trust_remote_code=True 
+)
+
+# Add LoRA adapter
+lora_config = LoraConfig(
+    r=rank,
+    lora_alpha=alpha,
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+    lora_dropout=dropout,
+    bias="none",
+    task_type=TaskType.CAUSAL_LM,
+)
+
+processed_path = "processed_sumobot_dataset"
+
+def tokenize(example):
+    if "messages" in example:
+        # Chat-format dataset
+        text = tokenizer.apply_chat_template(
+            example["messages"],
+            tokenize=False,
+            add_generation_prompt=False
+        )
+    elif "text" in example:
+        # Plain-text dataset
+        text = example["text"]
+    elif "state" in example and "action" in example:
+        text = f"""<|im_start|>system
+You are a Sumobot assistant.<|im_end|>
+<|im_start|>user
+sumobot state: {example['state']}<|im_end|>
+<|im_start|>assistant
+action: {example['action']}<|im_end|>"""
+    else:
+        raise ValueError("Example must contain 'messages', 'text', or 'state'+'action'")
+
+    # Tokenize with shorter max_length for smaller model
+    tokenized = tokenizer(
+        text,
+        truncation=True,
+        padding="max_length",
+        max_length=256  # SmolLM2 can handle shorter contexts efficiently
+    )
+    tokenized["labels"] = tokenized["input_ids"].copy()
+    return tokenized
+
+# IMPROVED: Better batching for tokenization
+if os.path.exists(processed_path):
+    print(f"✅ Found cached dataset at {processed_path}, loading...")
+    tokenized_datasets = load_from_disk(processed_path)
+else:
+    print("📊 Loading and tokenizing dataset...")
+    dataset = load_dataset(
+        "json",
+        data_files={
+            "train": dataset_train_output_path,
+            "val": dataset_val_output_path
+        }
+    )
+
+    # Tokenize with smaller batches to avoid memory spikes
+    tokenized_datasets = dataset.map(
+        tokenize,
+        batched=False,
+        load_from_cache_file=False,
+        # batch_size=100,  # Reduced from 1000
+        # remove_columns=dataset["train"].column_names,  # Remove original columns to save memory
+    )
+
+    print("💾 Saving tokenized dataset to disk...")
+    tokenized_datasets.save_to_disk(processed_path)
+    
+    # Clear memory after saving
+    del dataset
+    gc.collect()
+
+print(f"Train samples: {len(tokenized_datasets['train'])}")
+print(f"Val samples: {len(tokenized_datasets['val'])}")
+
+train_dataloader = DataLoader(
+    tokenized_datasets["train"],
+    batch_size=train_batches_per_device,
+    shuffle=True
+)
+
+train_length = len(train_dataloader)
+
+train_num = (train_length // gradient_accumulation) * num_train_epoch
+print(f"train length: {train_num}")
+
+del train_dataloader
+gc.collect()
+
+# FIXED: Proper training arguments for your setup
+training_args = TrainingArguments(
+    output_dir=adapter_folder_name,
+    
+    # Batch sizes - CRITICAL FIX
+    per_device_train_batch_size=train_batches_per_device,        # Small to save RAM
+    per_device_eval_batch_size=val_batches_per_device,         # Small to save RAM
+    gradient_accumulation_steps=gradient_accumulation,       # Increased to compensate
+    eval_accumulation_steps=eval_accumulation,
+    
+    # Memory optimization - CRITICAL FIXES
+    # dataloader_num_workers=0,             # No extra workers on Windows
+    # dataloader_pin_memory=False,          # Disable pinned memory
+    gradient_checkpointing=True,          # Enable checkpointing
+    
+    # Precision - FIXED TO MATCH MODEL
+    fp16=False,                           # CHANGED: Don't use fp16 with 4-bit
+    bf16=True,                            # CHANGED: Use bf16 to match model
+    
+    # Optimizer - Good choice for memory
+    # optim="paged_adamw_8bit",            # CHANGED: 8-bit saves more memory than 32bit
+    
+    # Training schedule
+    learning_rate=learning_rate,
+    num_train_epochs=num_train_epoch,
+    warmup_steps=100,
+    
+    # Checkpointing & logging
+    save_strategy="steps",
+    save_steps=max(50,int(train_num * save_ratio)),
+    logging_strategy="steps",
+    logging_steps=max(10,int(train_num * log_ratio)),
+    logging_dir=f"{adapter_folder_name}/outputs",
+    eval_strategy="steps",
+    eval_steps=int(train_num * eval_ratio),
+    
+    # Other
+    report_to="tensorboard",
+    dataloader_num_workers=0,
+    
+    # Additional memory saving options
+    # save_total_limit=2,                   # Keep only 2 checkpoints
+    load_best_model_at_end=False,        # Don't load model at end (saves memory)
+)
+
+data_collator = DataCollatorForLanguageModeling(
+    tokenizer=tokenizer,
+    mlm=False
+)
+
+# IMPORTANT: Disable cache for gradient checkpointing
+model.config.use_cache = False
+
+# Clear cache before training
+gc.collect()
+if torch.cuda.is_available():
+    torch.cuda.empty_cache()
+    torch.cuda.ipc_collect()
+
+print(f"🔧 Model memory footprint: {model.get_memory_footprint() / 1e9:.2f} GB")
+
+class CustomEarlyStopping(TrainerCallback):
+    def __init__(self, patience=5, min_delta=0.1):
+        self.patience = patience
+        self.min_delta = min_delta
+        self.best_loss = float("inf")
+        self.counter = 0
+
+    def on_evaluate(self, args, state, control, metrics=None, **kwargs):
+        val_loss = metrics.get("eval_loss")
+        if val_loss is None:
+            return control
+
+        if val_loss < self.best_loss - self.min_delta:
+            self.best_loss = val_loss
+            self.counter = 0
+            print(f"✅ Improved eval_loss to {val_loss:.4f}")
+        else:
+            self.counter += 1
+            print(f"⚠️ No significant improvement. Counter {self.counter}/{self.patience}")
+
+        if self.counter >= self.patience:
+            print("🛑 Early stopping triggered!")
+            control.should_training_stop = True
+
+        return control
+
+# Memory monitoring callback
+class MemoryMonitorCallback(TrainerCallback):
+    def on_step_end(self, args, state, control, **kwargs):
+        if state.global_step % 50 == 0:
+            import psutil
+            process = psutil.Process()
+            cpu_mem = process.memory_info().rss / 1e9
+            gpu_mem = torch.cuda.memory_allocated() / 1e9 if torch.cuda.is_available() else 0
+            print(f"📊 Step {state.global_step} | CPU RAM: {cpu_mem:.2f}GB | GPU RAM: {gpu_mem:.2f}GB")
+        return control
+
+# Trainer
+trainer = SFTTrainer(
+    model=model,
+    train_dataset=tokenized_datasets["train"],
+    eval_dataset=tokenized_datasets["val"],
+    peft_config=lora_config,
+    args=training_args,
+    data_collator=data_collator,
+    callbacks=[
+        CustomEarlyStopping(patience=10, min_delta=0.01),
+        MemoryMonitorCallback()
+    ]
+)
+
+# Enable resume from checkpoint
+latest_ckpt = None
+if os.path.isdir(adapter_folder_name):
+    checkpoints = [os.path.join(adapter_folder_name, d) for d in os.listdir(adapter_folder_name) if d.startswith("checkpoint-")]
+    if checkpoints:
+        latest_ckpt = max(checkpoints, key=lambda x: int(x.split("-")[-1]))
+        print(f"📂 Resuming from: {latest_ckpt}")
+
+# Train
+print("🚀 Starting training...")
+try:
+    if latest_ckpt:
+        trainer.train(resume_from_checkpoint=latest_ckpt)
+    else:
+        trainer.train()
+    
+    # Save LoRA adapter + tokenizer
+    print("💾 Saving model...")
+    trainer.model.save_pretrained(adapter_folder_name)
+    tokenizer.save_pretrained(adapter_folder_name)
+    print("��� Training complete!")
+    
+except Exception as e:
+    print(f"❌ Training failed with error: {e}")
+    import traceback
+    traceback.print_exc()

requirements.txt

@@ -1,17 +1,19 @@
-datasets==3.6.0
-huggingface_hub==0.34.5
-joblib==1.5.1
-numpy==1.26.4
-onnx==1.17.0
-onnxconverter_common==1.15.0
-onnxruntime==1.22.0
-pandas==2.3.2
-peft==0.15.2
-scikit_learn==1.7.2
-tensorflow==2.13.0
-tf2onnx==1.16.1
-tokenizers==0.22.0
-torch==2.7.0
-tqdm==4.67.1
-transformers==4.56.1
-trl==0.23.0
+datasets
+huggingface_hub
+joblib
+numpy
+onnx
+onnxconverter_common
+onnxruntime
+pandas
+peft
+scikit_learn
+tensorflow
+tf2onnx
+tokenizers
+torch
+tqdm
+transformers
+trl
+tf-keras
+bitsandbytes

slm/train_slm.ipynb

@@ -10,10 +10,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "id": "8b2f9c4b",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "curent dir slm\n"
+     ]
+    }
+   ],
    "source": [
     "import sys, os\n",
     "sys.path.append(os.path.abspath(\"..\"))\n",
@@ -25,8 +33,8 @@
     "\n",
     "# Amount of dataset lines that will be compiled and converted to dataset.jsonl. \n",
     "# If -1, use all lines.\n",
-    "max_dataset=100\n",
-    "# max_dataset=-1\n",
+    "# max_dataset=100\n",
+    "max_dataset=-1\n",
     "\n",
     "# Model parameters\n",
     "block_size = 128\n",
@@ -53,13 +61,132 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "id": "71e14182",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "curent dir slm\n",
+      "Reading local dataset from: ../dataset\n",
+      "No dataset found locally, will fetch from HuggingFace\n",
+      "Fetching dataset from HuggingFace repo: arbyazra123/sumobot_ml\n",
+      "Auto-detected 8 CSV files from HuggingFace.\n",
+      "dataset/game_logs_bt_vs_fsm.csv\n",
+      "dataset/game_logs_bt_vs_fsm_2.csv\n",
+      "dataset/game_logs_fsm_vs_bt.csv\n",
+      "dataset/game_logs_fsm_vs_fsm.csv\n",
+      "dataset/game_logs_mcts_vs_bt.csv\n",
+      "dataset/game_logs_mcts_vs_mcts.csv\n",
+      "dataset/game_logs_mcts_vs_primitive.csv\n",
+      "dataset/game_logs_primitive_vs_ga.csv\n",
+      "curent dir slm\n",
+      "../dataset\n",
+      "curent dir slm\n",
+      "Saved: ../dataset\\game_logs_bt_vs_fsm.csv\n",
+      "curent dir slm\n",
+      "../dataset\n",
+      "curent dir slm\n",
+      "Saved: ../dataset\\game_logs_bt_vs_fsm_2.csv\n",
+      "curent dir slm\n",
+      "../dataset\n",
+      "curent dir slm\n",
+      "Saved: ../dataset\\game_logs_fsm_vs_bt.csv\n",
+      "curent dir slm\n",
+      "../dataset\n",
+      "curent dir slm\n",
+      "Saved: ../dataset\\game_logs_fsm_vs_fsm.csv\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Xet Storage is enabled for this repo, but the 'hf_xet' package is not installed. Falling back to regular HTTP download. For better performance, install the package with: `pip install huggingface_hub[hf_xet]` or `pip install hf_xet`\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "curent dir slm\n",
+      "../dataset\n",
+      "curent dir slm\n",
+      "Saved: ../dataset\\game_logs_mcts_vs_bt.csv\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Xet Storage is enabled for this repo, but the 'hf_xet' package is not installed. Falling back to regular HTTP download. For better performance, install the package with: `pip install huggingface_hub[hf_xet]` or `pip install hf_xet`\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "curent dir slm\n",
+      "../dataset\n",
+      "curent dir slm\n",
+      "Saved: ../dataset\\game_logs_mcts_vs_mcts.csv\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Xet Storage is enabled for this repo, but the 'hf_xet' package is not installed. Falling back to regular HTTP download. For better performance, install the package with: `pip install huggingface_hub[hf_xet]` or `pip install hf_xet`\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "curent dir slm\n",
+      "../dataset\n",
+      "curent dir slm\n",
+      "Saved: ../dataset\\game_logs_mcts_vs_primitive.csv\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Xet Storage is enabled for this repo, but the 'hf_xet' package is not installed. Falling back to regular HTTP download. For better performance, install the package with: `pip install huggingface_hub[hf_xet]` or `pip install hf_xet`\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "curent dir slm\n",
+      "../dataset\n",
+      "curent dir slm\n",
+      "Saved: ../dataset\\game_logs_primitive_vs_ga.csv\n",
+      "Merged shape: (2597381, 51)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 2597381/2597381 [02:05<00:00, 20618.22it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saved 2597381 samples to ../dataset/slm_dataset.txt\n"
+     ]
+    }
+   ],
    "source": [
     "# Load data\n",
-    "df, dir = get_dataset(prefer_local=False)\n",
+    "df, dir = get_dataset()\n",
     "\n",
     "if max_dataset>-1:\n",
     "    df = df.sample(max_dataset)\n",
@@ -393,7 +520,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "sumobot_slm",
+   "display_name": "venv",
    "language": "python",
    "name": "python3"
   },
@@ -407,7 +534,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.18"
+   "version": "3.12.10"
   }
  },
  "nbformat": 4,

vdb/cleaned_dataset.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e494f13953a7911097d7062490626fee1ac7a82bc6323b848836e28a4468845
+size 312648863

vdb/dataset_cleaner.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""
+Clean and normalize actions in the dataset.
+Removes inconsistent outputs and keeps only valid action formats.
+"""
+
+import json
+import re
+from tqdm import tqdm
+
+def clean_action(action):
+    """
+    Clean and normalize action string
+    
+    Valid formats:
+    - TL (Turn Left) with optional value: TL, TL0.44
+    - TR (Turn Right) with optional value: TR, TR0.32
+    - FWD (Forward) with optional value: FWD, FWD0.38
+    - SK (Skip/Stay)
+    - DS (presumably another action)
+    
+    Args:
+        action: Raw action string from LLM
+    
+    Returns:
+        Cleaned action string or None if invalid
+    """
+    if not action:
+        return None
+    
+    # Remove extra whitespace
+    action = action.strip()
+    
+    # Pattern to match valid actions
+    # Matches: TL, TR, FWD, SK, DS with optional number
+    valid_pattern = r'^(TL|TR|FWD|SK|DS)(\d*\.?\d*)$'
+    
+    # Try to extract valid action
+    # Remove common LLM artifacts
+    action = action.split(',')[0]  # Take first part if comma-separated
+    action = action.split(':')[0]  # Remove score/explanation parts
+    action = action.split('score')[0]  # Remove 'score' text
+    action = action.strip()
+    
+    # Remove any extra text after the action
+    match = re.match(valid_pattern, action)
+    if match:
+        return action
+    
+    # Try to find valid action within the string
+    # Look for TL, TR, FWD, SK, or DS at the start
+    for prefix in ['TL', 'TR', 'FWD', 'SK', 'DS']:
+        if action.startswith(prefix):
+            # Extract the prefix and any following number
+            match = re.match(rf'^({prefix})(\d*\.?\d*)', action)
+            if match:
+                return match.group(0)
+    
+    # If nothing valid found, return None
+    return None
+
+def clean_dataset(input_file, output_file, invalid_output_file=None):
+    """
+    Clean dataset by normalizing actions
+    
+    Args:
+        input_file: Input JSONL file
+        output_file: Output JSONL file with cleaned actions
+        invalid_output_file: Optional file to save invalid entries
+    """
+    print("=" * 70)
+    print("Dataset Action Cleaner")
+    print("=" * 70)
+    print(f"Input: {input_file}")
+    print(f"Output: {output_file}")
+    if invalid_output_file:
+        print(f"Invalid entries: {invalid_output_file}")
+    print("=" * 70 + "\n")
+    
+    # Count lines first
+    print("Counting lines...")
+    total_lines = 0
+    with open(input_file, 'r') as f:
+        for _ in f:
+            total_lines += 1
+    print(f"Total lines: {total_lines:,}\n")
+    
+    # Process file
+    print("Cleaning actions...")
+    
+    valid_count = 0
+    invalid_count = 0
+    skipped_count = 0
+    
+    action_stats = {}
+    invalid_entries = []
+    
+    with open(input_file, 'r') as infile, open(output_file, 'w') as outfile:
+        for line in tqdm(infile, total=total_lines, desc="Processing"):
+            line = line.strip()
+            if not line:
+                skipped_count += 1
+                continue
+            
+            try:
+                data = json.loads(line)
+                state = data.get('state', '')
+                raw_action = data.get('action', '')
+                
+                # Clean action
+                cleaned_action = clean_action(raw_action)
+                
+                if cleaned_action:
+                    # Valid action
+                    result = {
+                        "state": state,
+                        "action": cleaned_action
+                    }
+                    outfile.write(json.dumps(result) + '\n')
+                    valid_count += 1
+                    
+                    # Track action statistics
+                    action_prefix = re.match(r'^[A-Z]+', cleaned_action)
+                    if action_prefix:
+                        prefix = action_prefix.group(0)
+                        action_stats[prefix] = action_stats.get(prefix, 0) + 1
+                else:
+                    # Invalid action
+                    invalid_count += 1
+                    invalid_entries.append({
+                        "state": state,
+                        "original_action": raw_action,
+                        "reason": "Could not parse valid action"
+                    })
+            
+            except json.JSONDecodeError:
+                skipped_count += 1
+                continue
+            except Exception as e:
+                skipped_count += 1
+                continue
+    
+    # Save invalid entries if requested
+    if invalid_output_file and invalid_entries:
+        print(f"\nSaving invalid entries to {invalid_output_file}...")
+        with open(invalid_output_file, 'w') as f:
+            for entry in invalid_entries:
+                f.write(json.dumps(entry) + '\n')
+    
+    # Print summary
+    print("\n" + "=" * 70)
+    print("Cleaning Summary")
+    print("=" * 70)
+    print(f"Total processed: {total_lines:,}")
+    print(f"Valid actions: {valid_count:,} ({100*valid_count/total_lines:.2f}%)")
+    print(f"Invalid actions: {invalid_count:,} ({100*invalid_count/total_lines:.2f}%)")
+    print(f"Skipped lines: {skipped_count:,}")
+    print("\nAction Statistics:")
+    for action, count in sorted(action_stats.items()):
+        print(f"  {action}: {count:,} ({100*count/valid_count:.2f}%)")
+    print("=" * 70)
+    print(f"\n✓ Cleaned dataset saved to: {output_file}")
+    if invalid_output_file and invalid_entries:
+        print(f"✓ Invalid entries saved to: {invalid_output_file}")
+    print()
+
+def preview_cleaning(input_file, num_samples=20):
+    """
+    Preview what the cleaning will do without modifying files
+    
+    Args:
+        input_file: Input file to preview
+        num_samples: Number of samples to show
+    """
+    print("=" * 70)
+    print("Cleaning Preview")
+    print("=" * 70 + "\n")
+    
+    samples_shown = 0
+    
+    with open(input_file, 'r') as f:
+        for line in f:
+            if samples_shown >= num_samples:
+                break
+            
+            line = line.strip()
+            if not line:
+                continue
+            
+            try:
+                data = json.loads(line)
+                raw_action = data.get('action', '')
+                cleaned_action = clean_action(raw_action)
+                
+                # Only show entries that will be changed or are invalid
+                if raw_action != cleaned_action:
+                    print(f"Original:  '{raw_action}'")
+                    print(f"Cleaned:   '{cleaned_action}'")
+                    if cleaned_action:
+                        print(f"Status:    ✓ Valid")
+                    else:
+                        print(f"Status:    ✗ Invalid (will be removed)")
+                    print("-" * 70)
+                    samples_shown += 1
+            
+            except:
+                continue
+    
+    print(f"\nShown {samples_shown} samples that will be modified/removed\n")
+
+if __name__ == "__main__":
+    
+    # ========================================
+    # CONFIGURATION
+    # ========================================
+    
+    input_file = "../llm/complete_dataset.jsonl"
+    output_file = "cleaned_dataset.jsonl"
+    invalid_file = "invalid_actions.jsonl"  # Set to None to skip saving
+    
+    # ========================================
+    # PREVIEW MODE
+    # ========================================
+    
+    print("\nDo you want to preview the cleaning first?")
+    response = input("Preview before cleaning? (y/n): ")
+    
+    if response.lower() == 'y':
+        preview_cleaning(input_file, num_samples=20)
+        print("\nDo you want to proceed with the full cleaning?")
+        response = input("Clean the dataset? (y/n): ")
+    
+    # ========================================
+    # CLEAN DATASET
+    # ========================================
+    
+    if response.lower() == 'y':
+        clean_dataset(input_file, output_file, invalid_file)
+        print("✓ All done!")
+    else:
+        print("Cancelled.")

vdb/import_data.py

@@ -18,7 +18,7 @@ def encode_state(state_str):
     ], dtype=np.float32)
 
 BATCH_SIZE = 5000
-DATA_PATH = "../dataset/temp.jsonl"
+DATA_PATH = "cleaned_dataset.jsonl"
 
 batch_vecs, batch_actions = [], []
 with open(DATA_PATH, "r") as f: