Upload train_on_colab.ipynb with huggingface_hub

train_on_colab.ipynb

@@ -0,0 +1,398 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# PULSE Temporal Awareness Training\n",
+        "**Fine-tune Qwen 2.5 1.5B with PULSE temporal awareness on free Colab GPU.**\n",
+        "\n",
+        "This notebook:\n",
+        "1. Generates 2000 synthetic temporal training examples\n",
+        "2. Fine-tunes Qwen 2.5 1.5B with LoRA (8.8M trainable params)\n",
+        "3. Uploads the model to Hugging Face Hub\n",
+        "\n",
+        "Runtime: ~20-30 min on T4 GPU\n",
+        "\n",
+        "---"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Step 0: Install dependencies\n",
+        "!pip install -q torch transformers peft trl datasets accelerate numpy huggingface_hub"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Step 0b: Login to HF (to upload the trained model)\n",
+        "from huggingface_hub import notebook_login\n",
+        "notebook_login()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Step 1: PULSE inline encoder + data generator\n",
+        "import json, random, numpy as np\n",
+        "from datetime import datetime, timedelta\n",
+        "\n",
+        "_COG = np.array([0.20,0.15,0.12,0.10,0.12,0.18,0.30,0.50,0.70,0.85,0.95,0.92,\n",
+        "                 0.85,0.72,0.68,0.75,0.88,0.90,0.82,0.70,0.55,0.40,0.30,0.25])\n",
+        "_NRG = np.array([0.15,0.10,0.08,0.07,0.10,0.20,0.40,0.60,0.75,0.85,0.90,0.88,\n",
+        "                 0.82,0.70,0.65,0.72,0.85,0.88,0.80,0.65,0.50,0.35,0.25,0.18])\n",
+        "\n",
+        "def _interp(c, h):\n",
+        "    h0 = int(h) % 24\n",
+        "    return float(c[h0]*(1-(h-int(h))) + c[(h0+1)%24]*(h-int(h)))\n",
+        "\n",
+        "def get_phase(h):\n",
+        "    if 6<=h<10: return 'morning_ramp'\n",
+        "    if 10<=h<12: return 'morning_peak'\n",
+        "    if 12<=h<14: return 'post_lunch_dip'\n",
+        "    if 14<=h<17: return 'afternoon_peak'\n",
+        "    if 17<=h<20: return 'evening_wind_down'\n",
+        "    if 20<=h<23: return 'night_transition'\n",
+        "    return 'deep_night'\n",
+        "\n",
+        "SYSTEM_TEMPLATE = \"\"\"You are an AI assistant with temporal awareness through the PULSE temporal embedding system. Before each interaction, you receive a temporal context package describing the current moment — not just the time, but what that time means: circadian phase, cognitive capacity, energy level, urgency, and behavioral context.\n",
+        "\n",
+        "Use this temporal awareness naturally in your responses. Don't announce it mechanically — weave it into your reasoning the way a thoughtful colleague would who knows what time it is and what's going on.\n",
+        "\n",
+        "Current temporal context:\n",
+        "{temporal_context}\"\"\"\n",
+        "\n",
+        "CONTEXTS = [\n",
+        "    ('monday_crunch',2.0,7,5),('critical_deadline',0.5,9,4),('normal_tuesday',None,3,7.5),\n",
+        "    ('focus_day',None,1,8),('deadline_tomorrow',24.0,5,7),('friday_winding',None,2,7),\n",
+        "    ('saturday_morning',None,0,9),('sunday_evening',12.0,0,7),('late_night',None,0,0),\n",
+        "    ('early_fresh',None,0,8),('post_lunch',None,4,7),('peak_morning',None,2,8),\n",
+        "    ('overdue',-2.0,8,4),('vacation',None,0,9),\n",
+        "]\n",
+        "\n",
+        "QUESTIONS = [\n",
+        "    ('Should I start a complex refactoring task right now?','task_suitability'),\n",
+        "    ('Is this a good time for creative brainstorming?','task_suitability'),\n",
+        "    ('Should I take a break right now?','break_advice'),\n",
+        "    ('How much focus can I expect right now?','cognitive_state'),\n",
+        "    ('What does my current temporal state look like?','full_state'),\n",
+        "    ('Am I in a good phase for deep work?','work_phase'),\n",
+        "    ('How urgent is my situation right now?','urgency_assessment'),\n",
+        "    ('Would I be more productive tomorrow morning?','timing_optimization'),\n",
+        "    ('How should I prioritize my remaining tasks?','prioritization'),\n",
+        "    ('What tasks should I tackle given my state?','task_matching'),\n",
+        "    ('Should I push through or call it a day?','endurance_check'),\n",
+        "    ('How does this moment compare to a typical morning?','relative_state'),\n",
+        "    ('Should I schedule a difficult conversation now?','task_suitability'),\n",
+        "    ('Is my energy level normal for this time?','circadian_comparison'),\n",
+        "    ('Would this be a good time to learn something new?','task_suitability'),\n",
+        "]\n",
+        "\n",
+        "def generate_response(question, q_sub, dt, dl_str, events, sleep):\n",
+        "    h = dt.hour + dt.minute/60\n",
+        "    cog, eng = _interp(_COG, h), _interp(_NRG, h)\n",
+        "    has_dl = dl_str is not None\n",
+        "    hours_left = (datetime.fromisoformat(dl_str)-dt).total_seconds()/3600 if has_dl else None\n",
+        "    is_overdue = has_dl and hours_left < 0\n",
+        "    is_urgent = has_dl and hours_left is not None and 0 < hours_left < 3\n",
+        "    is_night = dt.hour < 6 or dt.hour >= 22\n",
+        "    is_peak = 10<=dt.hour<12 or 14<=dt.hour<17\n",
+        "    is_dip = 12<=dt.hour<14\n",
+        "    is_low_sleep = sleep < 6\n",
+        "    p = []\n",
+        "    if q_sub == 'task_suitability':\n",
+        "        if any(w in question.lower() for w in ['complex','refactor','deep work','learn']):\n",
+        "            if is_peak and not is_low_sleep and cog>0.8:\n",
+        "                p.append(f'Ideal window. Cognitive capacity {cog:.0%} during peak hours.')\n",
+        "                if is_urgent: p.append(f'But deadline in {hours_left:.1f}h — prioritize what\\'s due.')\n",
+        "                elif not has_dl: p.append('No deadlines. Good time to dive deep.')\n",
+        "            elif is_dip: p.append(f'Post-lunch dip — {cog:.0%} capacity. Wait until ~3pm.')\n",
+        "            elif is_night: p.append(f'{dt.strftime(\"%I:%M %p\")}, cognition {cog:.0%}. Save for tomorrow.')\n",
+        "            elif is_low_sleep: p.append(f'{sleep:.0f}h sleep compromises capacity. Stick to routine tasks.')\n",
+        "            else: p.append(f'Moderate at {cog:.0%}. Not your peak window.')\n",
+        "        elif 'creative' in question.lower() or 'brainstorm' in question.lower():\n",
+        "            if is_dip: p.append('Reduced executive function helps creativity. Good for brainstorming.')\n",
+        "            elif is_peak: p.append(f'Peak capacity ({cog:.0%}) great for structured creative work.')\n",
+        "        elif 'break' in question.lower():\n",
+        "            if eng<0.4: p.append(f'Yes. Energy {eng:.0%}. Take 15-20 minutes.')\n",
+        "            elif is_dip: p.append('Natural dip. Short walk aligns with your rhythm.')\n",
+        "            else: p.append(f'Energy ({eng:.0%}) solid. Keep going if in flow.')\n",
+        "        elif 'conversation' in question.lower():\n",
+        "            if is_peak and not is_low_sleep: p.append(f'Capacity {cog:.0%} helps with emotional regulation.')\n",
+        "            else: p.append(f'Cognition {cog:.0%} — more reactive than reflective. Postpone if possible.')\n",
+        "    elif q_sub in ('full_state','cognitive_state','work_phase'):\n",
+        "        p.append(f'{dt.strftime(\"%A %I:%M %p\")}.')\n",
+        "        if is_peak: p.append(f'Peak window — {cog:.0%} capacity, {eng:.0%} energy.')\n",
+        "        elif is_dip: p.append(f'Post-lunch dip. {cog:.0%} cognition. Passes ~2:30pm.')\n",
+        "        elif is_night: p.append(f'Deep night. {cog:.0%} cognition. Body wants rest.')\n",
+        "        else: p.append(f'Capacity {cog:.0%}, energy {eng:.0%}.')\n",
+        "        if is_low_sleep: p.append(f'Sleep deficit ({sleep:.0f}h) — expect ~20% more errors.')\n",
+        "        if is_urgent: p.append(f'Deadline in {hours_left:.1f}h. Focused execution.')\n",
+        "    elif q_sub == 'urgency_assessment':\n",
+        "        if is_overdue: p.append(f'Critical. Deadline passed {-hours_left:.1f}h ago.')\n",
+        "        elif is_urgent: p.append(f'High — {hours_left:.1f}h to deadline. Only focus.')\n",
+        "        elif has_dl and hours_left<24: p.append(f'Moderate. {hours_left:.1f}h away.')\n",
+        "        else: p.append('No deadlines. Choose based on energy and interest.')\n",
+        "    elif q_sub == 'timing_optimization':\n",
+        "        if cog<0.5: p.append('Yes. Tomorrow 10-12am gives double your current capacity.')\n",
+        "        elif is_peak: p.append('Good window now. Waiting loses momentum.')\n",
+        "        else: p.append(f'Current {cog:.0%} vs tomorrow\\'s ~93%. Depends on complexity.')\n",
+        "    elif q_sub == 'prioritization':\n",
+        "        if is_urgent: p.append(f'Deadline first — {hours_left:.1f}h left.')\n",
+        "        elif is_peak: p.append('Peak for hardest task. Routine for the dip.')\n",
+        "        else: p.append(f'{cog:.0%} capacity. Match tasks to state.')\n",
+        "    elif q_sub == 'task_matching':\n",
+        "        if cog>0.8: p.append('Strong. Go for complex debugging, architecture, learning.')\n",
+        "        elif cog>0.5: p.append('Moderate. Code review, incremental features, docs.')\n",
+        "        else: p.append('Low. Email triage, filing issues, planning tomorrow.')\n",
+        "    elif q_sub == 'endurance_check':\n",
+        "        if eng<0.3: p.append(f'Call it. Energy {eng:.0%}. Past diminishing returns.')\n",
+        "        elif is_urgent: p.append(f'Push through — {hours_left:.1f}h to deadline.')\n",
+        "        elif is_dip: p.append('Circadian dip, not a wall. 15-min break restores.')\n",
+        "        else: p.append(f'Energy {eng:.0%}. Runway left if work engaging.')\n",
+        "    elif q_sub in ('relative_state','circadian_comparison'):\n",
+        "        p.append(f'Typical capacity at {dt.strftime(\"%I:%M %p\")}: ~{cog:.0%}.')\n",
+        "        if is_low_sleep: p.append(f'{sleep:.0f}h sleep puts you below baseline.')\n",
+        "    if not p: p.append(f'{cog:.0%} cognitive, {eng:.0%} energy, {dt.strftime(\"%A %I:%M %p\")}.')\n",
+        "    return ' '.join(p)\n",
+        "\n",
+        "def generate_dataset(n=2000, seed=42):\n",
+        "    rng = random.Random(seed)\n",
+        "    examples = []\n",
+        "    for _ in range(n):\n",
+        "        name,dl_off,events,sleep = rng.choice(CONTEXTS)\n",
+        "        dt = datetime(2026,rng.randint(1,12),rng.randint(1,28),rng.randint(0,23),rng.choice([0,15,30,45]))\n",
+        "        if 'late' in name: dt = dt.replace(hour=rng.choice([0,1,2,3]))\n",
+        "        elif 'early' in name: dt = dt.replace(hour=rng.choice([5,6,7]))\n",
+        "        elif 'peak' in name: dt = dt.replace(hour=rng.choice([10,11]))\n",
+        "        elif 'post_lunch' in name: dt = dt.replace(hour=rng.choice([13,14]))\n",
+        "        dl_str = (dt+timedelta(hours=dl_off)).isoformat() if dl_off else None\n",
+        "        h = dt.hour+dt.minute/60\n",
+        "        cog,eng = _interp(_COG,h),_interp(_NRG,h)\n",
+        "        urg = f'deadline in {dl_off:.1f}h' if dl_off and dl_off>0 else ('OVERDUE' if dl_off and dl_off<0 else 'none')\n",
+        "        tc = f\"\"\"Current time: {dt.strftime('%A, %B %d %Y at %I:%M %p')}\n",
+        "Circadian phase: {get_phase(dt.hour)}\n",
+        "Cognitive capacity: {cog:.0%}\n",
+        "Energy level: {eng:.0%}\n",
+        "Urgency: {urg}\n",
+        "Events today: {events}\n",
+        "Sleep last night: {sleep:.1f} hours\n",
+        "Weekend: {'yes' if dt.weekday()>=5 else 'no'}\"\"\"\n",
+        "        q, q_sub = rng.choice(QUESTIONS)\n",
+        "        r = generate_response(q, q_sub, dt, dl_str, events, sleep)\n",
+        "        examples.append({'messages': [\n",
+        "            {'role':'system','content':SYSTEM_TEMPLATE.format(temporal_context=tc)},\n",
+        "            {'role':'user','content':q},\n",
+        "            {'role':'assistant','content':r},\n",
+        "        ]})\n",
+        "    return examples\n",
+        "\n",
+        "print('Data generator ready.')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Step 2: Generate training data\n",
+        "train_data = generate_dataset(2000, seed=42)\n",
+        "eval_data = generate_dataset(200, seed=99)\n",
+        "print(f'Train: {len(train_data)}, Eval: {len(eval_data)}')\n",
+        "print(f'\\nSample:\\n{json.dumps(train_data[0][\"messages\"][1], indent=2)}')\n",
+        "print(f'\\nResponse: {train_data[0][\"messages\"][2][\"content\"][:200]}')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Step 3: Load model + LoRA\n",
+        "import torch\n",
+        "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
+        "from peft import LoraConfig, get_peft_model, TaskType\n",
+        "\n",
+        "MODEL_NAME = 'Qwen/Qwen2.5-1.5B-Instruct'  # Change to 0.5B for faster training\n",
+        "\n",
+        "print(f'Loading {MODEL_NAME}...')\n",
+        "tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)\n",
+        "tokenizer.pad_token = tokenizer.eos_token\n",
+        "\n",
+        "model = AutoModelForCausalLM.from_pretrained(\n",
+        "    MODEL_NAME, torch_dtype=torch.bfloat16, trust_remote_code=True,\n",
+        ")\n",
+        "\n",
+        "lora_config = LoraConfig(\n",
+        "    r=16, lora_alpha=32,\n",
+        "    target_modules=['q_proj','k_proj','v_proj','o_proj','gate_proj','up_proj','down_proj'],\n",
+        "    lora_dropout=0.05, bias='none', task_type=TaskType.CAUSAL_LM,\n",
+        ")\n",
+        "model = get_peft_model(model, lora_config)\n",
+        "t, total = model.get_nb_trainable_parameters()\n",
+        "print(f'LoRA: {t:,} trainable / {total:,} total ({100*t/total:.2f}%)')\n",
+        "print(f'GPU: {torch.cuda.get_device_name()}')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Step 4: Prepare dataset\n",
+        "from datasets import Dataset\n",
+        "\n",
+        "def format_chat(ex):\n",
+        "    return {'text': tokenizer.apply_chat_template(ex['messages'], tokenize=False, add_generation_prompt=False)}\n",
+        "\n",
+        "train_ds = Dataset.from_list(train_data).map(format_chat, remove_columns=['messages'])\n",
+        "eval_ds = Dataset.from_list(eval_data).map(format_chat, remove_columns=['messages'])\n",
+        "\n",
+        "# Check token lengths\n",
+        "sample_tokens = len(tokenizer.encode(train_ds[0]['text']))\n",
+        "print(f'Sample length: {sample_tokens} tokens')\n",
+        "print(f'Train: {len(train_ds)}, Eval: {len(eval_ds)}')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Step 5: Train!\n",
+        "from trl import SFTTrainer, SFTConfig\n",
+        "\n",
+        "OUTPUT_DIR = '/content/pulse-model'\n",
+        "\n",
+        "training_args = SFTConfig(\n",
+        "    output_dir=OUTPUT_DIR,\n",
+        "    num_train_epochs=3,\n",
+        "    per_device_train_batch_size=4,\n",
+        "    gradient_accumulation_steps=4,\n",
+        "    learning_rate=2e-4,\n",
+        "    lr_scheduler_type='cosine',\n",
+        "    warmup_ratio=0.1,\n",
+        "    logging_steps=10,\n",
+        "    save_strategy='epoch',\n",
+        "    eval_strategy='epoch',\n",
+        "    bf16=True,\n",
+        "    max_length=512,\n",
+        "    dataset_text_field='text',\n",
+        "    report_to='none',\n",
+        "    seed=42,\n",
+        ")\n",
+        "\n",
+        "trainer = SFTTrainer(\n",
+        "    model=model,\n",
+        "    args=training_args,\n",
+        "    train_dataset=train_ds,\n",
+        "    eval_dataset=eval_ds,\n",
+        "    processing_class=tokenizer,\n",
+        ")\n",
+        "\n",
+        "print('Training...')\n",
+        "trainer.train()\n",
+        "print('Done!')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Step 6: Save + Upload to HF Hub\n",
+        "from huggingface_hub import HfApi\n",
+        "\n",
+        "HF_REPO = 'lalopenguin/pulse-qwen-1.5b'  # Change to your repo\n",
+        "\n",
+        "# Save locally\n",
+        "trainer.save_model(OUTPUT_DIR)\n",
+        "tokenizer.save_pretrained(OUTPUT_DIR)\n",
+        "\n",
+        "# Save PULSE metadata\n",
+        "meta = {\n",
+        "    'base_model': MODEL_NAME,\n",
+        "    'pulse_version': '0.1.0',\n",
+        "    'training_type': 'temporal_awareness_sft',\n",
+        "    'lora_r': 16,\n",
+        "    'epochs': 3,\n",
+        "    'train_examples': len(train_data),\n",
+        "}\n",
+        "with open(f'{OUTPUT_DIR}/pulse_config.json', 'w') as f:\n",
+        "    json.dump(meta, f, indent=2)\n",
+        "\n",
+        "# Upload\n",
+        "api = HfApi()\n",
+        "api.create_repo(HF_REPO, exist_ok=True)\n",
+        "api.upload_folder(folder_path=OUTPUT_DIR, repo_id=HF_REPO, commit_message='PULSE temporal awareness LoRA')\n",
+        "print(f'\\nUploaded to https://huggingface.co/{HF_REPO}')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Step 7: Quick test\n",
+        "from peft import PeftModel\n",
+        "\n",
+        "# Reload clean\n",
+        "base = AutoModelForCausalLM.from_pretrained(MODEL_NAME, torch_dtype=torch.bfloat16, trust_remote_code=True)\n",
+        "model = PeftModel.from_pretrained(base, OUTPUT_DIR).to('cuda')\n",
+        "model.eval()\n",
+        "\n",
+        "messages = [\n",
+        "    {'role': 'system', 'content': SYSTEM_TEMPLATE.format(temporal_context=\"\"\"Current time: Monday, April 13 2026 at 02:00 PM\n",
+        "Circadian phase: afternoon_peak\n",
+        "Cognitive capacity: 68%\n",
+        "Energy level: 65%\n",
+        "Urgency: deadline in 3.0h\n",
+        "Events today: 6\n",
+        "Sleep last night: 5.0 hours\"\"\")},\n",
+        "    {'role': 'user', 'content': 'Should I start a complex refactoring task right now?'},\n",
+        "]\n",
+        "\n",
+        "inputs = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors='pt').to('cuda')\n",
+        "with torch.no_grad():\n",
+        "    out = model.generate(inputs, max_new_tokens=200, temperature=0.7, do_sample=True)\n",
+        "\n",
+        "response = tokenizer.decode(out[0][inputs.shape[1]:], skip_special_tokens=True)\n",
+        "print(f'Q: Should I start a complex refactoring task right now?\\n\\nA: {response}')"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python",
+      "version": "3.10.0"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}