finalize llm

classification/train_ml.ipynb

@@ -1,37 +1,5 @@
 {
  "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "11d756c9",
-   "metadata": {},
-   "source": [
-    "# Prepare environtment\n",
-    "If you're running offline (e.g. jupyter notebook), skip this step.\n",
-    "\n",
-    "But if online (e.g. Google Colab), need to clone first"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6d21801f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!pip install huggingface_hub\n",
-    "\n",
-    "from huggingface_hub import snapshot_download\n",
-    "\n",
-    "repo_id = \"arbyazra123/sumobot_ml\"\n",
-    "\n",
-    "# download the repo into local folder\n",
-    "local_dir = snapshot_download(repo_id=repo_id, repo_type=\"dataset\")\n",
-    "\n",
-    "# add to sys.path so Python can import from it\n",
-    "import sys\n",
-    "sys.path.append(local_dir)"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "def9fcb6",
@@ -52,17 +20,13 @@
     "import pandas as pd\n",
     "import glob\n",
     "\n",
-    "root_dir = os.getcwd().split(\"/\")[-1]\n",
-    "dataset_dir = \"\"\n",
-    "output_dir = \"\"\n",
-    "output_name = \"ml2.onnx\"\n",
-    "\n",
-    "if root_dir==\"classification\":\n",
-    "    dataset_dir = f\"../dataset\"\n",
-    "    output_dir = f\"model\"\n",
-    "else:\n",
-    "    dataset_dir = f\"dataset\"\n",
-    "    output_dir = f\"classification/model\""
+    "# 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",
+    "\n",
+    "output_onnx_name = \"ml.onnx\"\n",
+    "output_labels_name = \"ml_labels.json\"\n"
    ]
   },
   {
@@ -101,7 +65,8 @@
     "\n",
     "df, dir = get_dataset(inside_arena=True)\n",
     "\n",
-    "df.sample(100)\n",
+    "if max_dataset>-1:\n",
+    "    df = df.sample(max_dataset)\n",
     "\n",
     "features = [\n",
     "    \"BotPosX\", \n",
@@ -192,19 +157,18 @@
     "onnx_model, _ = tf2onnx.convert.from_keras(model, input_signature=spec, opset=13)\n",
     "\n",
     "# Save to file\n",
-    "_outputLoc = f\"{output_dir}/{output_name}\"\n",
-    "with open(_outputLoc, \"wb\") as f:\n",
+    "with open(output_onnx_name, \"wb\") as f:\n",
     "    f.write(onnx_model.SerializeToString())\n",
     "\n",
-    "print(f\"Model saved to {_outputLoc}\")\n",
+    "print(f\"Model saved to {output_onnx_name}\")\n",
     "\n",
     "class_labels = le.classes_.tolist()\n",
     "\n",
     "# Optional: Save labels to JSON\n",
-    "with open(f\"{output_dir}/action_labels.json\", \"w\") as f:\n",
+    "with open(output_labels_name, \"w\") as f:\n",
     "    json.dump(class_labels, f)\n",
     "\n",
-    "print(\"Exported label encoder classes to action_labels.json:\")\n",
+    "print(f\"Exported label encoder classes to {output_labels_name}\")\n",
     "print(class_labels)"
    ]
   },
@@ -228,10 +192,10 @@
     "import joblib\n",
     "\n",
     "# Load ONNX session\n",
-    "session = ort.InferenceSession(f\"{output_dir}/{output_name}\")\n",
+    "session = ort.InferenceSession(output_onnx_name)\n",
     "\n",
     "# Load label encoder\n",
-    "le = joblib.load(\"../pkls/label_encoder.pkl\")\n",
+    "le = joblib.load(output_labels_name)\n",
     "\n",
     "# 1 sample input (bisa ambil dari X_test atau manual)\n",
     "sample = np.array([[\n",

dataset_helper.py

@@ -305,13 +305,28 @@ def export_dataset(df, output_path, format="txt", completion_mode="normal", incl
                 if format == "txt":
                     line = f"{prompt_str} Result: {', '.join(actions)}"
                     f.write(line + "\n")
-                elif format == "jsonl":
+                elif format == "jsonl_prompt_completion":
                     line = f"You are a Sumobot assistant. Given this state: {prompt_str} Suggested Action:"
                     record = {
                         "prompt": line,
                         "completion": ', '.join(actions)
                     }
                     f.write(json.dumps(record) + "\n")
+                elif format == "jsonl_message":
+                    record = {
+                        "messages": [
+                            {"role": "system", "content": "You are a Sumobot assistant that decides actions based on game state."},
+                            {"role": "user", "content": f"Given this game state: {prompt_str}"},
+                            {"role": "assistant", "content": ', '.join(actions)}
+                        ]
+                    }
+                    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)}"
+                    record = {
+                        "text": line,
+                    }
+                    f.write(json.dumps(record) + "\n")
                 
 
             except Exception as e:
@@ -324,10 +339,17 @@ def filter_inside_arena(df, margin=0.95):
 
 def get_dataset_dir():
     root_dir = os.getcwd().split("/")[-1]
+
+    # For online notebook
+    if root_dir == "content": 
+        path = "dataset"
+        os.makedirs(path, exist_ok=True)
+        return "dataset"
+    
     if root_dir=="slm" or root_dir=="llm" or "classification":
         return f"../dataset"
     else:
-        return f"dataset"
+        return "dataset"
     
 def get_slm_dir():
     root_dir = os.getcwd().split("/")[-1]
@@ -339,13 +361,14 @@ def get_slm_dir():
 
 def get_dataset(
     prefer_local: bool = True,
-    inside_arena: bool = False
+    inside_arena: bool = False,
+    save_downloaded_dataset :bool = True
 ):
     local_dataset_path = get_dataset_dir()
     dfs = []
 
     if not prefer_local:  # Use HuggingFace
-        dfs = get_dataset_from_hf()
+        dfs = get_dataset_from_hf(save_downloaded_dataset=save_downloaded_dataset)
     else:
         print(f"Reading local dataset from: {local_dataset_path}")
         csv_files = glob.glob(os.path.join(local_dataset_path, "*.csv"))
@@ -356,7 +379,7 @@ def get_dataset(
 
     if not dfs:
         print("No dataset found locally, will fetch from HuggingFace")
-        dfs = get_dataset_from_hf()
+        dfs = get_dataset_from_hf(save_downloaded_dataset=save_downloaded_dataset)
 
     # Merge into one DataFrame
     merged_df = pd.concat(dfs, ignore_index=True)
@@ -368,14 +391,15 @@ def get_dataset(
 
 def get_dataset_from_hf(
         repo_id: str = "arbyazra123/sumobot_ml",
-        repo_dataset_path: str = "dataset"):
+        repo_dataset_path: str = "dataset",
+        save_downloaded_dataset :bool = True):
     
     print(f"Fetching dataset from HuggingFace repo: {repo_id}")
     dfs = []
     
     all_files = list_repo_files(repo_id=repo_id, repo_type="dataset")
     hf_csv_files = [f for f in all_files if f.startswith(repo_dataset_path) and f.endswith(".csv")]
-    
+
     print(f"Auto-detected {len(hf_csv_files)} CSV files from HuggingFace.")
     print("\n".join(hf_csv_files))
 
@@ -388,4 +412,9 @@ def get_dataset_from_hf(
         df = pd.read_csv(file_path)
         df["source_file"] = os.path.basename(fname)
         dfs.append(df)
+
+        if save_downloaded_dataset:
+            save_path = os.path.join(get_dataset_dir(), os.path.basename(fname))
+            df.to_csv(save_path, index=False)
+            print(f"Saved: {save_path}")
     return dfs

llm/train_llm.ipynb

@@ -2,13 +2,11 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "id": "27fcb17a",
+   "id": "ac0a4693",
    "metadata": {},
    "source": [
-    "# Prepare environtment\n",
-    "If you're running offline (e.g. jupyter notebook), skip this step.\n",
-    "\n",
-    "But if online (e.g. Google Colab), need to clone first"
+    "# Requirements\n",
+    "This project (LLM) need to run requirements.txt"
    ]
   },
   {
@@ -18,18 +16,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install huggingface_hub\n",
-    "\n",
-    "from huggingface_hub import snapshot_download\n",
-    "\n",
-    "repo_id = \"arbyazra123/sumobot_ml\"\n",
-    "\n",
-    "# download the repo into local folder\n",
-    "local_dir = snapshot_download(repo_id=repo_id, repo_type=\"dataset\")\n",
-    "\n",
-    "# add to sys.path so Python can import from it\n",
-    "import sys\n",
-    "sys.path.append(local_dir)"
+    "!pip install -r requirements.txt"
    ]
   },
   {
@@ -52,27 +39,33 @@
     "\n",
     "from dataset_helper import export_dataset, get_dataset, get_dataset_dir\n",
     "\n",
-    "# Amount of dataset lines that will be compiled and converted to dataset.jsonl. \n",
+    "# Amount of dataset lines that will be compiled and converted to dataset.jsonl.\n",
     "# If -1, use all lines.\n",
-    "max_dataset=1_000_000\n",
+    "max_dataset=10_000\n",
     "# max_dataset=-1    # Use all lines\n",
+    "train_validation_ratio=0.9\n",
     "\n",
     "# Training args\n",
-    "batches_per_device=1    # 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=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=1\n",
-    "learning_rate=1e-5\n",
-    "save_every=10_000\n",
+    "gradient_accumulation=12\n",
+    "eval_accumulation=1\n",
+    "learning_rate=5e-5\n",
+    "save_every=0.5          #ratio\n",
     "log_every=10\n",
+    "eval_ratio=20         #ratio\n",
     "\n",
     "# LoRA\n",
     "rank=32\n",
     "alpha=64\n",
     "dropout=0.01\n",
     "\n",
+    "model_name = \"Qwen/Qwen2.5-0.5B-Instruct\"\n",
+    "\n",
     "adapter_folder_name=\"adapters/qwen2.5_0.5b_lora\"\n",
-    "dataset_output_path = f\"{get_dataset_dir()}/llm_dataset.jsonl\""
+    "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\""
    ]
   },
   {
@@ -90,15 +83,39 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "from sklearn.model_selection import train_test_split\n",
+    "\n",
     "# Load data\n",
     "df, dir = get_dataset()\n",
     "\n",
     "if max_dataset>-1:\n",
     "    df = df.sample(max_dataset)\n",
-    "    \n",
-    "export_dataset(df, dataset_output_path, format=\"jsonl\", completion_mode=\"normal\", include_pos_rot=False)\n",
     "\n",
-    "print(f\"Saved {len(df)} samples to {dataset_output_path}\")"
+    "df_train, df_val = train_test_split(\n",
+    "    df,\n",
+    "    train_size=train_validation_ratio,\n",
+    "    random_state=42,\n",
+    "    shuffle=True\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",
+    "    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}\")"
    ]
   },
   {
@@ -138,17 +155,13 @@
    },
    "outputs": [],
    "source": [
+    "from functools import partial\n",
     "import json\n",
     "import torch\n",
-    "from transformers import (\n",
-    "    AutoTokenizer,\n",
-    "    AutoModelForCausalLM,\n",
-    "    Trainer,\n",
-    "    TrainingArguments,\n",
-    "    DataCollatorForLanguageModeling\n",
-    ")\n",
+    "from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, DataCollatorForLanguageModeling\n",
     "from datasets import load_dataset\n",
-    "from peft import LoraConfig, get_peft_model, TaskType\n",
+    "from peft import LoraConfig, TaskType\n",
+    "from trl import SFTTrainer\n",
     "\n",
     "# Device detection (MPS/CUDA)\n",
     "if torch.backends.mps.is_available():\n",
@@ -164,9 +177,6 @@
     "print(f\"Using device: {device}\")\n",
     "\n",
     "# Load Qwen2.5-0.5B model & tokenizer\n",
-    "model_name = \"Qwen/Qwen2.5-0.5B\"\n",
-    "\n",
-    "\n",
     "tokenizer = AutoTokenizer.from_pretrained(\n",
     "    model_name,\n",
     "    trust_remote_code=True\n",
@@ -178,7 +188,7 @@
     "\n",
     "model = AutoModelForCausalLM.from_pretrained(\n",
     "    model_name,\n",
-    "    torch_dtype=torch.float16,   # safe default\n",
+    "    # torch_dtype=torch.float16,   # safe default\n",
     "    device_map=device_map,\n",
     "    trust_remote_code=True\n",
     ")\n",
@@ -187,37 +197,43 @@
     "lora_config = LoraConfig(\n",
     "    r=rank,\n",
     "    lora_alpha=alpha,\n",
-    "    target_modules=[\"q_proj\",\"v_proj\"],\n",
+    "    target_modules=[\"q_proj\", \"v_proj\"],\n",
     "    lora_dropout=dropout,\n",
     "    bias=\"none\",\n",
     "    task_type=TaskType.CAUSAL_LM,\n",
     ")\n",
-    "model = get_peft_model(model, lora_config)\n",
     "\n",
-    "# Load dataset\n",
-    "dataset = load_dataset(\"json\", data_files={\"train\": dataset_output_path})\n",
-    "# dataset = dataset[\"train\"].select(range(10_000))\n",
-    "dataset = dataset[\"train\"]\n",
+    "# Load both train & val splits\n",
+    "dataset = load_dataset(\n",
+    "    \"json\",\n",
+    "    data_files={\n",
+    "        \"train\": dataset_train_output_path,\n",
+    "        \"val\": dataset_val_output_path\n",
+    "    }\n",
+    ")\n",
     "\n",
-    "def tokenize_function(examples):\n",
-    "    # Convert dicts into text strings for training\n",
-    "    merged_texts = []\n",
-    "    for p, c in zip(examples[\"prompt\"], examples[\"completion\"]):\n",
-    "        merged_texts.append(json.dumps({\"prompt\": p, \"completion\": c}))\n",
-    "    return tokenizer(merged_texts, truncation=True, padding=\"max_length\", max_length=256)\n",
+    "def tokenize(example):\n",
+    "    # Convert structured messages → chat text\n",
+    "    text = tokenizer.apply_chat_template(\n",
+    "        example[\"messages\"],\n",
+    "        tokenize=False,\n",
+    "        add_generation_prompt=False  # training: we include the assistant text\n",
+    "    )\n",
+    "    # Tokenize (labels = input_ids for causal LM training)\n",
+    "    tokenized = tokenizer(\n",
+    "        text,\n",
+    "        truncation=True,\n",
+    "        padding=\"max_length\",\n",
+    "        max_length=512  # adjust depending on context size\n",
+    "    )\n",
+    "    tokenized[\"labels\"] = tokenized[\"input_ids\"].copy()\n",
+    "    return tokenized\n",
     "\n",
     "\n",
+    "# Tokenize train\n",
     "tokenized_datasets = dataset.map(\n",
-    "    tokenize_function,\n",
-    "    batched=True,\n",
-    "    num_proc=4,\n",
-    "    remove_columns=[\"prompt\", \"completion\"]  # remove original cols\n",
-    ")\n",
-    "\n",
-    "# Data collator\n",
-    "data_collator = DataCollatorForLanguageModeling(\n",
-    "    tokenizer=tokenizer,\n",
-    "    mlm=False\n",
+    "    tokenize,\n",
+    "    batched=False\n",
     ")\n",
     "\n",
     "# Training setup\n",
@@ -225,30 +241,39 @@
     "    output_dir=adapter_folder_name,\n",
     "    per_device_train_batch_size=batches_per_device,\n",
     "    gradient_accumulation_steps=gradient_accumulation,\n",
+    "    eval_accumulation_steps=eval_accumulation,\n",
     "    learning_rate=learning_rate,\n",
     "    num_train_epochs=num_train_epoch,\n",
     "    save_strategy=\"steps\",\n",
     "    save_steps=save_every,\n",
     "    logging_strategy=\"steps\",\n",
+    "    eval_strategy=\"steps\",\n",
+    "    eval_steps=eval_ratio,\n",
     "    logging_steps=log_every,\n",
     "    report_to=\"none\",\n",
     "    fp16=torch.cuda.is_available(),\n",
     ")\n",
     "\n",
+    "data_collator = DataCollatorForLanguageModeling(\n",
+    "    tokenizer=tokenizer,\n",
+    "    mlm=False  # we want causal LM training\n",
+    ")\n",
+    "\n",
     "# Trainer\n",
-    "trainer = Trainer(\n",
+    "trainer = SFTTrainer(\n",
     "    model=model,\n",
+    "    train_dataset=tokenized_datasets[\"train\"],\n",
+    "    eval_dataset=tokenized_datasets[\"val\"],\n",
+    "    peft_config=lora_config,\n",
     "    args=training_args,\n",
-    "    train_dataset=tokenized_datasets,\n",
-    "    tokenizer=tokenizer,\n",
-    "    data_collator=data_collator,\n",
+    "    data_collator=data_collator\n",
     ")\n",
     "\n",
-    "# Train \n",
+    "# Train\n",
     "trainer.train()\n",
     "\n",
     "# Save LoRA adapter + tokenizer\n",
-    "model.save_pretrained(adapter_folder_name)\n",
+    "trainer.model.save_pretrained(adapter_folder_name)\n",
     "tokenizer.save_pretrained(adapter_folder_name)\n"
    ]
   },
@@ -270,36 +295,84 @@
     "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
     "from peft import PeftModel\n",
     "\n",
-    "base_model = \"Qwen/Qwen2.5-0.5B\"  \n",
-    "\n",
     "# Load tokenizer\n",
-    "tokenizer = AutoTokenizer.from_pretrained(base_model)\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
     "\n",
     "# Load base model\n",
     "model = AutoModelForCausalLM.from_pretrained(\n",
-    "    base_model,\n",
-    "    device_map=\"auto\",   # or \"cuda\"\n",
+    "    model_name,\n",
+    "    device_map=\"auto\",   # or \"cuda\" if you have NVIDIA\n",
     "    torch_dtype=\"auto\"\n",
     ")\n",
     "\n",
-    "# Load LoRA adapter into the base model\n",
+    "# Load LoRA adapter\n",
     "model = PeftModel.from_pretrained(model, adapter_folder_name)\n",
     "\n",
-    "# Merge if you want a standalone model (optional)\n",
-    "# model = model.merge_and_unload()\n",
+    "# Merge LoRA into the base model (optional if you want a standalone model)\n",
+    "model = model.merge_and_unload()\n",
+    "\n",
+    "# Inference with chat template\n",
+    "messages = [\n",
+    "    {\"role\": \"system\", \"content\": \"You are a Sumobot assistant that decides actions based on game state.\"},\n",
+    "    {\"role\": \"user\", \"content\": \"Given this game state: AngleToEnemy=8.11, AngleToEnemyScore=0.99, DistanceToEnemyScore=0.81, NearBorderArenaScore=0.19, FacingToArena=-0.98.\"},\n",
+    "]\n",
+    "\n",
+    "# Apply the tokenizer's built-in chat template\n",
+    "chat_prompt = tokenizer.apply_chat_template(\n",
+    "    messages,\n",
+    "    tokenize=False,             \n",
+    "    add_generation_prompt=True   \n",
+    ")\n",
     "\n",
-    "# Inference\n",
-    "prompt = \"You are a Sumobot assistant. Given this state: AngleToEnemy=89.89, AngleToEnemyScore=0.00, DistanceToEnemyScore=0.63, NearBorderArenaScore=0.36, FacingToArena=0.02. Suggested Action:\"\n",
-    "inputs = tokenizer(prompt, return_tensors=\"pt\").to(model.device)\n",
+    "inputs = tokenizer(chat_prompt, return_tensors=\"pt\").to(model.device)\n",
     "\n",
     "outputs = model.generate(\n",
     "    **inputs,\n",
-    "    max_new_tokens=128,\n",
-    "    temperature=0.1,\n",
-    "    top_p=0.9\n",
+    "    max_new_tokens=128\n",
+    ")\n",
+    "\n",
+    "print(tokenizer.decode(outputs[0], skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "05789a5e",
+   "metadata": {},
+   "source": [
+    "# Save merged model - OPTIONAL"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1e491e7e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
+    "from peft import PeftModel\n",
+    "\n",
+    "# Load tokenizer\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
+    "\n",
+    "# Load base model\n",
+    "model = AutoModelForCausalLM.from_pretrained(\n",
+    "    model_name,\n",
+    "    device_map=\"auto\",   # or \"cuda\" if you have NVIDIA\n",
+    "    torch_dtype=\"auto\"\n",
     ")\n",
     "\n",
-    "print(tokenizer.decode(outputs[0], skip_special_tokens=True))\n"
+    "# Load LoRA adapter\n",
+    "model = PeftModel.from_pretrained(model, adapter_folder_name)\n",
+    "\n",
+    "# Merge LoRA into the base model (optional if you want a standalone model)\n",
+    "model = model.merge_and_unload()\n",
+    "\n",
+    "# Save merged adapter (LoRA) with base model - OPTIONAL\n",
+    "save_path = \"qwen2.5-0.5b-instruct-sumobot-merged\"\n",
+    "\n",
+    "model.save_pretrained(save_path, safe_serialization=True)\n",
+    "tokenizer.save_pretrained(save_path)"
    ]
   }
  ],
@@ -310,7 +383,7 @@
    "provenance": []
   },
   "kernelspec": {
-   "display_name": "sumobot_slm",
+   "display_name": "ml",
    "language": "python",
    "name": "python3"
   },
@@ -324,7 +397,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.18"
+   "version": "3.10.16"
   },
   "widgets": {
    "application/vnd.jupyter.widget-state+json": {

llm/train_llm.py

@@ -1,203 +0,0 @@
-# %% [markdown]
-# # Configurations
-
-# %%
-import sys, os
-sys.path.append(os.path.abspath(".."))
-
-from dataset_helper import export_dataset, get_dataset, get_dataset_dir
-
-# Amount of dataset lines that will be compiled and converted to dataset.jsonl. 
-# If -1, use all lines.
-max_dataset=1_000_000
-# max_dataset=-1    # Use all lines
-
-# Training args
-batches_per_device=1    # adjust based on GPU CUDA / MPS power. Using standard laptop RAM is suggested to set 1. Example (1,2,4,8)
-# batches_per_device=8
-num_train_epoch=2       # num train 2-3 is enough
-gradient_accumulation=1
-learning_rate=1e-5
-save_every=10_000
-log_every=10
-
-# LoRA
-rank=32
-alpha=64
-dropout=0.01
-
-adapter_folder_name="adapters/qwen2.5_0.5b_lora"
-dataset_output_path = f"{get_dataset_dir()}/llm_dataset.jsonl"
-
-# %% [markdown]
-# # Load Data
-
-# %%
-# Load data
-df, dir = get_dataset()
-
-if max_dataset>-1:
-    df = df.sample(max_dataset)
-    
-export_dataset(df, dataset_output_path, format="jsonl", completion_mode="normal", include_pos_rot=False)
-
-print(f"Saved {len(df)} samples to {dataset_output_path}")
-
-# %% [markdown]
-# # Fine-tuning with LoRA
-
-# %%
-import json
-import torch
-from transformers import (
-    AutoTokenizer,
-    AutoModelForCausalLM,
-    Trainer,
-    TrainingArguments,
-    DataCollatorForLanguageModeling
-)
-from datasets import load_dataset
-from peft import LoraConfig, get_peft_model, TaskType
-
-# Device detection (MPS/CUDA)
-if torch.backends.mps.is_available():
-    device = torch.device("mps")
-    device_map = {"": "mps"}
-elif torch.cuda.is_available():
-    device = torch.device("cuda")
-    device_map = {"": "cuda"}
-else:
-    device = torch.device("cpu")
-    device_map = {"": "cpu"}
-
-print(f"Using device: {device}")
-
-# Load Qwen2.5-0.5B model & tokenizer
-model_name = "Qwen/Qwen2.5-0.5B"
-
-
-tokenizer = AutoTokenizer.from_pretrained(
-    model_name,
-    trust_remote_code=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,
-    torch_dtype=torch.float16,   # safe default
-    device_map=device_map,
-    trust_remote_code=True
-)
-
-# Add LoRA adapter
-lora_config = LoraConfig(
-    r=rank,
-    lora_alpha=alpha,
-    target_modules=["q_proj","v_proj"],
-    lora_dropout=dropout,
-    bias="none",
-    task_type=TaskType.CAUSAL_LM,
-)
-model = get_peft_model(model, lora_config)
-
-# Load dataset
-dataset = load_dataset("json", data_files={"train": dataset_output_path})
-# dataset = dataset["train"].select(range(10_000))
-dataset = dataset["train"]
-
-def tokenize_function(examples):
-    # Convert dicts into text strings for training
-    merged_texts = []
-    for p, c in zip(examples["prompt"], examples["completion"]):
-        merged_texts.append(json.dumps({"prompt": p, "completion": c}))
-    return tokenizer(merged_texts, truncation=True, padding="max_length", max_length=256)
-
-
-tokenized_datasets = dataset.map(
-    tokenize_function,
-    batched=True,
-    num_proc=4,
-    remove_columns=["prompt", "completion"]  # remove original cols
-)
-
-# Data collator
-data_collator = DataCollatorForLanguageModeling(
-    tokenizer=tokenizer,
-    mlm=False
-)
-
-# Training setup
-training_args = TrainingArguments(
-    output_dir=adapter_folder_name,
-    per_device_train_batch_size=batches_per_device,
-    gradient_accumulation_steps=gradient_accumulation,
-    learning_rate=learning_rate,
-    num_train_epochs=num_train_epoch,
-    save_strategy="steps",
-    save_steps=save_every,
-    logging_strategy="steps",
-    logging_steps=log_every,
-    report_to="none",
-    fp16=torch.cuda.is_available(),
-)
-
-# Trainer
-trainer = Trainer(
-    model=model,
-    args=training_args,
-    train_dataset=tokenized_datasets,
-    tokenizer=tokenizer,
-    data_collator=data_collator,
-)
-
-# Train 
-trainer.train()
-
-# Save LoRA adapter + tokenizer
-model.save_pretrained(adapter_folder_name)
-tokenizer.save_pretrained(adapter_folder_name)
-
-
-# %% [markdown]
-# # Testing
-
-# %%
-from transformers import AutoModelForCausalLM, AutoTokenizer
-from peft import PeftModel
-
-base_model = "Qwen/Qwen2.5-0.5B"  
-
-# Load tokenizer
-tokenizer = AutoTokenizer.from_pretrained(base_model)
-
-# Load base model
-model = AutoModelForCausalLM.from_pretrained(
-    base_model,
-    device_map="auto",   # or "cuda"
-    torch_dtype="auto"
-)
-
-# Load LoRA adapter into the base model
-model = PeftModel.from_pretrained(model, adapter_folder_name)
-
-# Merge if you want a standalone model (optional)
-# model = model.merge_and_unload()
-
-# Inference
-prompt = "You are a Sumobot assistant. Given this state: AngleToEnemy=89.89, AngleToEnemyScore=0.00, DistanceToEnemyScore=0.63, NearBorderArenaScore=0.36, FacingToArena=0.02. Suggested Action:"
-inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
-
-outputs = model.generate(
-    **inputs,
-    max_new_tokens=128,
-    temperature=0.1,
-    top_p=0.9
-)
-
-print(tokenizer.decode(outputs[0], skip_special_tokens=True))
-
-
-

requirements.txt

@@ -1,16 +1,18 @@
-datasets==4.0.0
-huggingface_hub==0.34.4
-joblib==1.5.2
-numpy==2.3.3
+datasets==3.6.0
+huggingface_hub==0.34.5
+joblib==1.5.1
+numpy==1.26.4
 onnx==1.17.0
-onnxconverter_common==1.16.0
-onnxruntime==1.22.1
+onnxconverter_common==1.15.0
+onnxruntime==1.22.0
 pandas==2.3.2
-peft==0.17.1
+peft==0.15.2
 scikit_learn==1.7.2
-tensorflow==2.20.0
+tensorflow==2.13.0
+# tensorflow_macos==2.13.0 # uncomment if necessary
 tf2onnx==1.16.1
 tokenizers==0.22.0
-torch==2.8.0
+torch==2.7.0
 tqdm==4.67.1
 transformers==4.56.1
+trl==0.23.0

slm/train_slm.ipynb

@@ -1,43 +1,11 @@
 {
  "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "988a4872",
-   "metadata": {},
-   "source": [
-    "# Prepare environtment\n",
-    "If you're running offline (e.g. jupyter notebook), skip this step.\n",
-    "\n",
-    "But if online (e.g. Google Colab), need to clone first"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "aeb9f4bc",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!pip install huggingface_hub\n",
-    "\n",
-    "from huggingface_hub import snapshot_download\n",
-    "\n",
-    "repo_id = \"arbyazra123/sumobot_ml\"\n",
-    "\n",
-    "# download the repo into local folder\n",
-    "local_dir = snapshot_download(repo_id=repo_id, repo_type=\"dataset\")\n",
-    "\n",
-    "# add to sys.path so Python can import from it\n",
-    "import sys\n",
-    "sys.path.append(local_dir)"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "1a948356",
    "metadata": {},
    "source": [
-    "# Configuratino"
+    "# Configurations"
    ]
   },
   {
@@ -289,7 +257,7 @@
    "id": "9d1d8d70",
    "metadata": {},
    "source": [
-    "# Training"
+    "# Training and save to onnx"
    ]
   },
   {

slm/train_slm.py

@@ -1,319 +0,0 @@
-# %% [markdown]
-# # Configuratino
-
-# %%
-import sys, os
-sys.path.append(os.path.abspath(".."))
-
-import torch
-from dataset_helper import export_dataset, get_dataset, get_slm_dir, get_dataset_dir
-
-device = 'cuda' if torch.cuda.is_available() else 'cpu'
-
-# Amount of dataset lines that will be compiled and converted to dataset.jsonl. 
-# If -1, use all lines.
-max_dataset=100
-# max_dataset=-1
-
-# Model parameters
-block_size = 128
-batch_size = 256
-n_embed = 192
-n_heads = 4
-n_layers = 3
-lr = 1e-4
-max_iters = 5000
-eval_interval = 100
-
-onnx_output_name="slm"
-dataset_output_path = f"{get_dataset_dir()}/slm_dataset.txt"
-tokenizer_output_path = f"{get_slm_dir()}/slm_tokenizer.json"
-
-# %% [markdown]
-# # Load Data
-
-# %%
-# Load data
-df, dir = get_dataset(prefer_local=False)
-
-if max_dataset>-1:
-    df = df.sample(max_dataset)
-    
-export_dataset(df, dataset_output_path, format="txt", completion_mode="short")
-
-print(f"Saved {len(df)} samples to {dataset_output_path}")
-
-# %% [markdown]
-# # Tokenization
-
-# %%
-from tokenizers import Tokenizer, models, pre_tokenizers, decoders, trainers
-
-# Tokenization
-tokenizer = Tokenizer(models.BPE())
-tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel(add_prefix_space=True)
-tokenizer.decoder = decoders.ByteLevel()
-specials = ["<PAD>"]
-# Tokenization - Train
-trainer = trainers.BpeTrainer(special_tokens=specials)
-tokenizer.train([dataset_output_path], trainer)
-for tok in specials:
-    tokenizer.add_special_tokens([tok])
-# Tokenization - Save to file
-tokenizer.save(tokenizer_output_path)
-print(f"✅ Tokenizer saved to {tokenizer_output_path}")
-
-
-# Load Tokenizer
-data_file = open(dataset_output_path, "r", encoding="utf-8")
-
-tokenizer = Tokenizer.from_file(tokenizer_output_path)
-vocab_size = tokenizer.get_vocab_size()
-
-# %% [markdown]
-# # Prepare Model
-
-# %%
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from tqdm import tqdm
-from tokenizers import Tokenizer
-
-def line_token_stream(file):
-    for line in file:
-        tokens = tokenizer.encode(line).ids
-        yield tokens
-
-token_stream = line_token_stream(data_file)
-
-def get_batch_linear():
-    global token_stream
-    x_batch, y_batch = [], []
-
-    while len(x_batch) < batch_size:
-        try:
-            tokens = next(token_stream)
-        except StopIteration:
-            # Restart from beginning
-            data_file.seek(0)
-            token_stream = line_token_stream(data_file)
-            tokens = next(token_stream)
-
-        # Pad or trim
-        if len(tokens) < block_size + 1:
-            tokens += [0] * (block_size + 1 - len(tokens))
-        else:
-            tokens = tokens[:block_size + 1]
-
-        x_batch.append(tokens[:-1])
-        y_batch.append(tokens[1:])
-
-    return (
-        torch.tensor(x_batch, dtype=torch.long, device=device),
-        torch.tensor(y_batch, dtype=torch.long, device=device)
-    )
-
-# === Model ===
-class Head(nn.Module):
-    def __init__(self, head_size):
-        super().__init__()
-        self.key = nn.Linear(n_embed, head_size, bias=False)
-        self.query = nn.Linear(n_embed, head_size, bias=False)
-        self.value = nn.Linear(n_embed, head_size, bias=False)
-        self.register_buffer('tril', torch.tril(torch.ones(block_size, block_size)))
-
-    def forward(self, x):
-        B, T, C = x.shape
-        k = self.key(x)
-        q = self.query(x)
-        wei = q @ k.transpose(-2, -1) / (C ** 0.5)
-        wei = wei.masked_fill(self.tril[:T, :T] == 0, float('-inf'))
-        wei = F.softmax(wei, dim=-1)
-        v = self.value(x)
-        return wei @ v
-
-class MultiHeadAttention(nn.Module):
-    def __init__(self, num_heads, head_size):
-        super().__init__()
-        self.heads = nn.ModuleList([Head(head_size) for _ in range(num_heads)])
-        self.proj = nn.Linear(n_embed, n_embed)
-
-    def forward(self, x):
-        out = torch.cat([h(x) for h in self.heads], dim=-1)
-        return self.proj(out)
-
-class FeedForward(nn.Module):
-    def __init__(self, n_embed):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.Linear(n_embed, 4 * n_embed),
-            nn.ReLU(),
-            nn.Linear(4 * n_embed, n_embed)
-        )
-
-    def forward(self, x):
-        return self.net(x)
-
-class Block(nn.Module):
-    def __init__(self, n_embed, n_heads):
-        super().__init__()
-        head_size = n_embed // n_heads
-        self.sa = MultiHeadAttention(n_heads, head_size)
-        self.ffwd = FeedForward(n_embed)
-        self.ln1 = nn.LayerNorm(n_embed)
-        self.ln2 = nn.LayerNorm(n_embed)
-
-    def forward(self, x):
-        x = x + self.sa(self.ln1(x))
-        x = x + self.ffwd(self.ln2(x))
-        return x
-
-class GPT(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.token_embedding = nn.Embedding(vocab_size, n_embed)
-        self.pos_embedding = nn.Embedding(block_size, n_embed)
-        self.blocks = nn.Sequential(*[Block(n_embed, n_heads) for _ in range(n_layers)])
-        self.ln_f = nn.LayerNorm(n_embed)
-        self.head = nn.Linear(n_embed, vocab_size)
-
-    def forward(self, idx, targets=None):
-        B, T = idx.shape
-        tok_emb = self.token_embedding(idx)
-        pos_emb = self.pos_embedding(torch.arange(T, device=device))
-        x = tok_emb + pos_emb
-        x = self.blocks(x)
-        x = self.ln_f(x)
-        logits = self.head(x)
-
-        if targets is None:
-            return logits, None
-
-        loss = F.cross_entropy(logits.view(-1, vocab_size), targets.view(-1))
-        return logits, loss
-
-    def generate(self, idx, max_new_tokens=50):
-        for _ in range(max_new_tokens):
-            idx_cond = idx[:, -block_size:]
-            logits, _ = self(idx_cond)
-            probs = F.softmax(logits[:, -1, :], dim=-1)
-            next_idx = torch.multinomial(probs, num_samples=1)
-            idx = torch.cat((idx, next_idx), dim=1)
-        return idx
-
-# %% [markdown]
-# # Training
-
-# %%
-# Training
-model = GPT().to(device)
-optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
-
-for step in tqdm(range(max_iters)):
-    xb, yb = get_batch_linear()  # sequential batching
-    logits, loss = model(xb, yb)
-    optimizer.zero_grad()
-    loss.backward()
-    optimizer.step()
-
-    if step % eval_interval == 0:
-        val_x, val_y = get_batch_linear()  # sequential validation
-        _, val_loss = model(val_x, val_y)
-        print(f"Step {step}: train loss {loss.item():.4f}, val loss {val_loss.item():.4f}")
-
-# Generation
-# Encode example prompt
-context_ids = tokenizer.encode("BotPos=[2.23,2.25], BotRot=228, EnemyPos=[2.87,0.39], EnemyRot=87, AngleToEnemy=-29.68, AngleToEnemyScore=0.87, DistanceToEnemyScore=0.79, NearBorderArenaScore=0.42, FacingToArena=0.65.").ids
-context = torch.tensor(context_ids, dtype=torch.long, device=device).unsqueeze(0)
-
-# Generate
-output_ids = model.generate(context, max_new_tokens=20)[0].tolist()
-
-# Decode generated IDs back to text
-output_text = tokenizer.decode(output_ids)
-print(output_text)
-
-model.eval()
-
-# Dummy input: batch=1, variable sequence length (start small for export)
-dummy_input = torch.randint(0, vocab_size, (1, 8), dtype=torch.long, device=device)
-
-torch.onnx.export(
-    model,
-    dummy_input,
-    f"{onnx_output_name}.onnx",
-    input_names=["input_ids"],
-    output_names=["logits"],
-    dynamic_axes={
-        "input_ids": {0: "batch_size", 1: "sequence_length"},
-        "logits": {0: "batch_size", 1: "sequence_length"}
-    },
-    opset_version=13
-)
-
-print(f"✅ Exported GPT model to {onnx_output_name}.onnx")
-
-# Quantize the model - OPTIONAL
-import onnx
-from onnxconverter_common import float16
-model = onnx.load(f"{onnx_output_name}.onnx")
-fp16_model = float16.convert_float_to_float16(model)
-onnx.save(fp16_model, f"{onnx_output_name}_fp16.onnx")
-
-# %% [markdown]
-# # Testing
-
-# %%
-from time import sleep
-from tokenizers import Tokenizer
-import numpy as np
-import onnxruntime as ort
-
-# Load trained BPE tokenizer
-tokenizer = Tokenizer.from_file(tokenizer_output_path)
-vocab_size = tokenizer.get_vocab_size()
-
-# Load ONNX model
-session = ort.InferenceSession(f"{onnx_output_name}.onnx", providers=['CPUExecutionProvider'])
-
-def generate_onnx(prompt, max_new_tokens=20, block_size=128):
-    # Encode with BPE tokenizer
-    input_ids = tokenizer.encode(prompt).ids
-    for _ in range(max_new_tokens):
-        # Keep only last block_size tokens
-        input_slice = input_ids[-block_size:]
-        input_array = np.array([input_slice], dtype=np.int64)
-
-        # Run inference
-        outputs = session.run(None, {"input_ids": input_array})
-        logits = outputs[0]  # shape: (1, seq_len, vocab_size)
-
-        # Get last token logits
-        next_token_logits = logits[0, -1]
-        next_token_id = int(np.argmax(next_token_logits))
-
-        pred = tokenizer.decode([next_token_id])
-
-        # Optional stop condition (EOS token index)
-        if pred == "\n":
-            break
-        
-        # sleep(0.1)
-        input_ids.append(next_token_id)
-        print(f"[{pred}]", end="", flush=True)
-
-
-
-    # Decode IDs back to string
-    return tokenizer.decode(input_ids)
-
-# Test run
-prompt = (
-    "BotPos=[2.23,2.25], BotRot=228, EnemyPos=[2.87,0.39], EnemyRot=87, AngleToEnemy=-29.68, AngleToEnemyScore=0.87, DistanceToEnemyScore=0.79, NearBorderArenaScore=0.42, FacingToArena=0.65. Suggested Action:"
-)
-
-output = generate_onnx(prompt, max_new_tokens=300)
-print(f"\n\n🧠 Output {len(output)}:", output)
-
-