training/train_grpo.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Viraltest v2 — Real LLM Training with LoRA + Environment Rewards\n",
        "\n",
        "This notebook **actually trains** an LLM (Qwen2.5-1.5B-Instruct) to play our Instagram creator simulation.\n",
        "\n",
        "**Pipeline:**\n",
        "1. Clone repo & install deps\n",
        "2. Run 5 heuristic baselines × 3 tasks (15 runs) → leaderboard\n",
        "3. Run **untrained** LLM on all 3 tasks → \"before\" scores\n",
        "4. **LoRA fine-tune** with reward-weighted SFT (4 rounds × 6 episodes = real weight updates)\n",
        "5. Run **trained** LLM on all 3 tasks → \"after\" scores\n",
        "6. Generate real plots from real numbers\n",
        "\n",
        "**Requirements:** Colab T4 GPU (free tier), ~45 min total.\n",
        "\n",
        "**What makes this real training:** LoRA adapter weights are actually updated via gradient descent. The model's behavior changes because its weights change, not because we edit the prompt.\n",
        "\n",
        "**Before this notebook:** run `training/syntax_only.ipynb` (kernel + syntax only) and `training/train_grpo_smoke.ipynb` (repo + env). Pip lines use quoted package specs so Colab/zsh does not break on `>=`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m25.3\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m26.0.1\u001b[0m\n",
            "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
            "\n",
            "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m25.3\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m26.0.1\u001b[0m\n",
            "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
            "\n",
            "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m25.3\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m26.0.1\u001b[0m\n",
            "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
            "\n",
            "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m25.3\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m26.0.1\u001b[0m\n",
            "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
            "\n",
            "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m25.3\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m26.0.1\u001b[0m\n",
            "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n"
          ]
        }
      ],
      "source": [
        "# Cell 1: Install dependencies (quote versions — zsh treats `>` as redirect otherwise)\n",
        "!pip install -q torch torchvision torchaudio\n",
        "!pip install -q \"transformers>=4.45.0\" \"accelerate\" \"peft>=0.10.0\" \"trl>=0.20.0\" \"datasets\" \"bitsandbytes\"\n",
        "!pip install -q matplotlib pandas\n",
        "!pip install -q \"typing_extensions>=4.13.0\" pydantic httpx\n",
        "!pip install -q \"openenv-core[core]>=0.2.2\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Mode: local\n",
            "Repo root: /Users/anurag.c/viral-posts-env\n",
            "Working dir: /Users/anurag.c/viral-posts-env\n",
            "Branch: hack1\n",
            "Commit: aedc9c7\n",
            "Plots dir: /Users/anurag.c/viral-posts-env/plots\n"
          ]
        }
      ],
      "source": [
        "# Cell 2: Resolve repo path (Colab: fresh clone. Local: auto-detect project root)\n",
        "import os\n",
        "import sys\n",
        "import shutil\n",
        "import subprocess\n",
        "from pathlib import Path\n",
        "\n",
        "REPO_BRANCH = \"hack1\"\n",
        "REPO_URL = \"https://github.com/VaibhavKhandare/viral-posts-env.git\"\n",
        "COLAB_REPO = Path(\"/content/viral-posts-env\")\n",
        "\n",
        "\n",
        "def _is_repo_root(p: Path) -> bool:\n",
        "    return (p / \"server\" / \"viraltest_environment.py\").is_file() and (p / \"models.py\").is_file()\n",
        "\n",
        "\n",
        "def _find_local_root() -> Path:\n",
        "    here = Path.cwd().resolve()\n",
        "    for cand in (here, here.parent, here.parent.parent):\n",
        "        if _is_repo_root(cand):\n",
        "            return cand\n",
        "    raise FileNotFoundError(\n",
        "        \"Could not find project root. cd into viral-posts-env or run this notebook in Google Colab.\"\n",
        "    )\n",
        "\n",
        "\n",
        "# --- Colab: always clone a clean copy (avoids stale 7-day code) ---\n",
        "if Path(\"/content\").is_dir():\n",
        "    if COLAB_REPO.exists():\n",
        "        shutil.rmtree(COLAB_REPO, ignore_errors=True)\n",
        "    p = subprocess.run(\n",
        "        [\n",
        "            \"git\", \"clone\", \"--branch\", REPO_BRANCH, \"--depth\", \"1\",\n",
        "            REPO_URL, str(COLAB_REPO),\n",
        "        ],\n",
        "        capture_output=True,\n",
        "        text=True,\n",
        "    )\n",
        "    if p.returncode != 0:\n",
        "        raise RuntimeError(\n",
        "            \"git clone failed. Check network and branch name.\\n\"\n",
        "            f\"stdout:\\n{p.stdout}\\nstderr:\\n{p.stderr}\"\n",
        "        )\n",
        "    if not COLAB_REPO.is_dir():\n",
        "        raise FileNotFoundError(f\"Clone did not create {COLAB_REPO}\")\n",
        "    os.chdir(COLAB_REPO)\n",
        "    print(\"Mode: Colab (fresh clone)\")\n",
        "else:\n",
        "    # --- Local machine: do not use /content ---\n",
        "    root = _find_local_root()\n",
        "    os.chdir(root)\n",
        "    print(\"Mode: local\")\n",
        "    print(f\"Repo root: {root}\")\n",
        "\n",
        "REPO_DIR = str(Path.cwd().resolve())\n",
        "if REPO_DIR not in sys.path:\n",
        "    sys.path.insert(0, REPO_DIR)\n",
        "\n",
        "PLOTS_DIR = os.path.join(REPO_DIR, \"plots\")\n",
        "os.makedirs(PLOTS_DIR, exist_ok=True)\n",
        "\n",
        "try:\n",
        "    commit = subprocess.check_output(\n",
        "        [\"git\", \"rev-parse\", \"--short\", \"HEAD\"],\n",
        "        stderr=subprocess.DEVNULL,\n",
        "        text=True,\n",
        "    ).strip()\n",
        "except Exception:\n",
        "    commit = \"n/a\"\n",
        "\n",
        "print(f\"Working dir: {os.getcwd()}\")\n",
        "print(f\"Branch: {REPO_BRANCH}\")\n",
        "print(f\"Commit: {commit}\")\n",
        "print(f\"Plots dir: {PLOTS_DIR}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "/Users/anurag.c/viral-posts-env/.venv/lib/python3.14/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"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "GPU: CPU\n",
            "Tags: 114, Topics: 100, Horizon: 30 days\n"
          ]
        }
      ],
      "source": [
        "# Cell 3: Imports (with runtime validation)\n",
        "import json, random, time, textwrap, copy, os, sys\n",
        "from pathlib import Path\n",
        "from typing import Any, Dict, List, Optional, Tuple\n",
        "from collections import defaultdict\n",
        "\n",
        "# Find repo root if notebook was opened from training/ and Cell 2 was skipped\n",
        "if not Path(\"server/viraltest_environment.py\").is_file():\n",
        "    for cand in (Path.cwd(), Path.cwd().parent, Path.cwd().parent.parent):\n",
        "        if (cand / \"server\" / \"viraltest_environment.py\").is_file():\n",
        "            os.chdir(cand)\n",
        "            s = str(cand.resolve())\n",
        "            if s not in sys.path:\n",
        "                sys.path.insert(0, s)\n",
        "            print(\"Auto chdir to repo root:\", s)\n",
        "            break\n",
        "    else:\n",
        "        raise RuntimeError(\n",
        "            \"Project files not found. Run **Cell 2** first (Colab), or run from repo root.\\n\"\n",
        "            f\"  cwd = {os.getcwd()!r}\\n\"\n",
        "        )\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import torch\n",
        "\n",
        "from models import ScheduledAction, ToolCall, ViraltestAction\n",
        "from server.viraltest_environment import (\n",
        "    ViraltestEnvironment, TAG_POOL, TASK_HORIZON,\n",
        "    TOPIC_CATEGORIES,\n",
        ")\n",
        "\n",
        "ALL_TOPICS = [t for topics in TOPIC_CATEGORIES.values() for t in topics]\n",
        "NICHES = list(TOPIC_CATEGORIES.keys())\n",
        "CONTENT_TYPES = [\"reel\", \"carousel\", \"story\", \"text_post\"]\n",
        "INTENTS = [\"send_bait\", \"save_bait\", \"watch_bait\", \"like_bait\"]\n",
        "TASKS = [\"monthly_engage\", \"monthly_strategic\", \"monthly_competitive\"]\n",
        "\n",
        "print(f\"GPU: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'CPU'}\")\n",
        "print(f\"Tags: {len(TAG_POOL)}, Topics: {len(ALL_TOPICS)}, Horizon: {TASK_HORIZON} days\")\n",
        "\n",
        "# Same sanity as syntax_only.ipynb (kernel parses modern Python)\n",
        "import ast\n",
        "ast.parse(\"def _t(x: int) -> str: return f'{x}'\")\n",
        "print(\"OK: ast.parse (syntax check)\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Part 1: Heuristic Baselines\n",
        "\n",
        "5 scripted agents prove the environment differentiates skill levels."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Agents and episode runner defined.\n"
          ]
        }
      ],
      "source": [
        "# Cell 4: Define heuristic agents + episode runner\n",
        "_rng = random.Random(42)\n",
        "\n",
        "def plan_always_rest(obs_dict, day):\n",
        "    return ViraltestAction(scheduled_actions=[])\n",
        "\n",
        "def plan_spam(obs_dict, day):\n",
        "    return ViraltestAction(scheduled_actions=[\n",
        "        ScheduledAction(hour=h, action_type=\"post\", content_type=\"reel\",\n",
        "                        topic=\"AI tools\", tags=[\"ai\"], intent=\"watch_bait\")\n",
        "        for h in range(24)])\n",
        "\n",
        "def plan_random(obs_dict, day):\n",
        "    actions = []\n",
        "    for h in range(24):\n",
        "        if _rng.random() < 0.1:\n",
        "            actions.append(ScheduledAction(\n",
        "                hour=h, action_type=\"post\",\n",
        "                content_type=_rng.choice(CONTENT_TYPES),\n",
        "                topic=_rng.choice(ALL_TOPICS),\n",
        "                tags=_rng.sample(TAG_POOL[:30], 3),\n",
        "                intent=_rng.choice(INTENTS)))\n",
        "    return ViraltestAction(scheduled_actions=actions)\n",
        "\n",
        "def plan_minimal(obs_dict, day):\n",
        "    return ViraltestAction(scheduled_actions=[\n",
        "        ScheduledAction(hour=12, action_type=\"post\", content_type=\"carousel\",\n",
        "                        topic=ALL_TOPICS[day % len(ALL_TOPICS)],\n",
        "                        tags=[TAG_POOL[i % len(TAG_POOL)] for i in range(day, day+3)],\n",
        "                        intent=\"save_bait\")])\n",
        "\n",
        "def plan_smart(obs_dict, day):\n",
        "    return ViraltestAction(\n",
        "        tool_calls=[ToolCall(name=\"query_trends\",\n",
        "                   arguments={\"niche\": NICHES[day % len(NICHES)]})] if day <= 3 else [],\n",
        "        scheduled_actions=[\n",
        "            ScheduledAction(hour=8, action_type=\"create_content\"),\n",
        "            ScheduledAction(hour=12, action_type=\"post\",\n",
        "                content_type=CONTENT_TYPES[(day*2)%4],\n",
        "                topic=ALL_TOPICS[(day*2)%len(ALL_TOPICS)],\n",
        "                tags=[TAG_POOL[(day*6+i)%len(TAG_POOL)] for i in range(3)],\n",
        "                intent=INTENTS[(day*2)%4]),\n",
        "            ScheduledAction(hour=19, action_type=\"post\",\n",
        "                content_type=CONTENT_TYPES[(day*2+1)%4],\n",
        "                topic=ALL_TOPICS[(day*2+1)%len(ALL_TOPICS)],\n",
        "                tags=[TAG_POOL[(day*6+3+i)%len(TAG_POOL)] for i in range(3)],\n",
        "                intent=INTENTS[(day*2+1)%4]),\n",
        "        ])\n",
        "\n",
        "BASELINE_AGENTS = {\n",
        "    \"always_rest\": plan_always_rest, \"spam\": plan_spam,\n",
        "    \"random\": plan_random, \"minimal\": plan_minimal, \"smart\": plan_smart,\n",
        "}\n",
        "\n",
        "def run_episode(task, plan_fn, seed=42):\n",
        "    env = ViraltestEnvironment()\n",
        "    obs = env.reset(task=task, seed=seed)\n",
        "    obs_dict = obs.model_dump()\n",
        "    rewards, energies = [], [obs.creator_energy]\n",
        "    for day in range(1, TASK_HORIZON + 1):\n",
        "        action = plan_fn(obs_dict, day)\n",
        "        obs = env.step(action)\n",
        "        obs_dict = obs.model_dump()\n",
        "        rewards.append(obs.reward or 0.0)\n",
        "        energies.append(obs.creator_energy)\n",
        "        if obs.done: break\n",
        "    grader = (obs.metadata or {}).get(\"grader_score\", 0.0)\n",
        "    return {\"grader_score\": grader, \"total_reward\": sum(rewards),\n",
        "            \"steps\": len(rewards), \"final_energy\": obs.creator_energy,\n",
        "            \"follower_delta\": obs.follower_count - 10000,\n",
        "            \"burned_out\": obs.creator_energy <= 0,\n",
        "            \"rewards\": rewards, \"energies\": energies}\n",
        "\n",
        "print(\"Agents and episode runner defined.\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Running heuristic baselines (5 agents × 3 tasks)...\n",
            "======================================================================\n",
            "   always_rest |         monthly_engage | score=0.0000 | energy=1.00\n",
            "   always_rest |      monthly_strategic | score=0.1750 | energy=1.00\n",
            "   always_rest |    monthly_competitive | score=0.0350 | energy=1.00\n",
            "\n",
            "          spam |         monthly_engage | score=0.0042 | energy=0.00\n",
            "          spam |      monthly_strategic | score=0.0075 | energy=0.00\n",
            "          spam |    monthly_competitive | score=0.0000 | energy=0.00\n",
            "\n",
            "        random |         monthly_engage | score=0.5389 | energy=0.92\n",
            "        random |      monthly_strategic | score=0.6403 | energy=0.92\n",
            "        random |    monthly_competitive | score=0.6678 | energy=0.92\n",
            "\n",
            "       minimal |         monthly_engage | score=0.4145 | energy=1.00\n",
            "       minimal |      monthly_strategic | score=0.7220 | energy=1.00\n",
            "       minimal |    monthly_competitive | score=0.3850 | energy=1.00\n",
            "\n",
            "         smart |         monthly_engage | score=0.7883 | energy=1.00\n",
            "         smart |      monthly_strategic | score=0.8932 | energy=1.00\n",
            "         smart |    monthly_competitive | score=0.8986 | energy=1.00\n",
            "\n",
            "\n",
            "LEADERBOARD\n",
            "Agent              Engage    Strategic    Competitive      Avg\n",
            "------------------------------------------------------------\n",
            "always_rest        0.0000       0.1750         0.0350   0.0700\n",
            "spam               0.0042       0.0075         0.0000   0.0039\n",
            "random             0.5389       0.6403         0.6678   0.6157\n",
            "minimal            0.4145       0.7220         0.3850   0.5072\n",
            "smart              0.7883       0.8932         0.8986   0.8600\n"
          ]
        }
      ],
      "source": [
        "# Cell 5: Run baselines (safe)\n",
        "print(\"Running heuristic baselines (5 agents × 3 tasks)...\")\n",
        "print(\"=\" * 70)\n",
        "\n",
        "required = [\"BASELINE_AGENTS\", \"run_episode\", \"TASKS\", \"random\"]\n",
        "missing = [k for k in required if k not in globals()]\n",
        "if missing:\n",
        "    raise RuntimeError(\n",
        "        f\"Missing prerequisites: {missing}. Run notebook from top (Cell 1 -> Cell 5).\"\n",
        "    )\n",
        "\n",
        "baseline_results = {}\n",
        "for name, fn in BASELINE_AGENTS.items():\n",
        "    baseline_results[name] = {}\n",
        "    for task in TASKS:\n",
        "        _rng = random.Random(42)\n",
        "        try:\n",
        "            result = run_episode(task, fn, seed=42)\n",
        "        except Exception as e:\n",
        "            raise RuntimeError(\n",
        "                f\"Baseline failed for agent={name}, task={task}: {type(e).__name__}: {e}\"\n",
        "            ) from e\n",
        "        baseline_results[name][task] = result\n",
        "        print(f\"  {name:>12s} | {task:>22s} | score={result['grader_score']:.4f} \"\n",
        "              f\"| energy={result['final_energy']:.2f}\")\n",
        "    print()\n",
        "\n",
        "print(\"\\nLEADERBOARD\")\n",
        "print(f\"{'Agent':<14s} {'Engage':>10s} {'Strategic':>12s} {'Competitive':>14s} {'Avg':>8s}\")\n",
        "print(\"-\" * 60)\n",
        "for name in BASELINE_AGENTS:\n",
        "    scores = [baseline_results[name][t][\"grader_score\"] for t in TASKS]\n",
        "    print(f\"{name:<14s} {scores[0]:>10.4f} {scores[1]:>12.4f} {scores[2]:>14.4f} {sum(scores)/3:>8.4f}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1600x500 with 3 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Cell 6: Baseline plots\n",
        "fig, axes = plt.subplots(1, 3, figsize=(16, 5), sharey=True)\n",
        "agent_names = list(BASELINE_AGENTS.keys())\n",
        "colors = ['#E53935', '#FF9800', '#9E9E9E', '#42A5F5', '#4CAF50']\n",
        "for i, task in enumerate(TASKS):\n",
        "    scores = [baseline_results[a][task][\"grader_score\"] for a in agent_names]\n",
        "    bars = axes[i].barh(agent_names, scores, color=colors)\n",
        "    axes[i].set_title(task.replace(\"monthly_\", \"\").title(), fontsize=13, fontweight='bold')\n",
        "    for bar, score in zip(bars, scores):\n",
        "        axes[i].text(bar.get_width() + 0.005, bar.get_y() + bar.get_height()/2,\n",
        "                     f\"{score:.4f}\", va='center', fontsize=9)\n",
        "axes[0].set_ylabel(\"Agent\")\n",
        "fig.suptitle(\"Viraltest v2 — Heuristic Baseline Leaderboard\", fontsize=14, fontweight='bold')\n",
        "fig.tight_layout()\n",
        "fig.savefig(f\"{PLOTS_DIR}/baseline_leaderboard.png\", dpi=150, bbox_inches='tight')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Part 2: Load LLM (Qwen2.5-1.5B-Instruct)\n",
        "\n",
        "We load the base model with 4-bit quantization to fit in free Colab's T4 GPU (16GB VRAM)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Loading Qwen/Qwen2.5-1.5B-Instruct without 4-bit (bitsandbytes/CUDA unavailable).\n",
            "  On Colab: run `pip install -U bitsandbytes>=0.46.1` and use a GPU runtime.\n",
            "  On Mac: use fp16 on MPS or fp32 on CPU.\n"
          ]
        },
        {
          "ename": "KeyboardInterrupt",
          "evalue": "",
          "output_type": "error",
          "traceback": [
            "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
            "\u001b[31mKeyboardInterrupt\u001b[39m                         Traceback (most recent call last)",
            "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[7]\u001b[39m\u001b[32m, line 44\u001b[39m\n\u001b[32m     40\u001b[39m         \u001b[33m\"  On Colab: run `pip install -U bitsandbytes>=0.46.1` and use a GPU runtime.\\n\"\u001b[39m\n\u001b[32m     41\u001b[39m         \u001b[33m\"  On Mac: use fp16 on MPS or fp32 on CPU.\"\u001b[39m\n\u001b[32m     42\u001b[39m     )\n\u001b[32m     43\u001b[39m     dtype = torch.float16 \u001b[38;5;28;01mif\u001b[39;00m (torch.cuda.is_available() \u001b[38;5;28;01mor\u001b[39;00m getattr(torch.backends, \u001b[33m\"mps\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m) \u001b[38;5;28;01mand\u001b[39;00m torch.backends.mps.is_available()) \u001b[38;5;28;01melse\u001b[39;00m torch.float32\n\u001b[32m---> \u001b[39m\u001b[32m44\u001b[39m     model = AutoModelForCausalLM.from_pretrained(\n\u001b[32m     45\u001b[39m         MODEL_NAME,\n\u001b[32m     46\u001b[39m         trust_remote_code=\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[32m     47\u001b[39m         dtype=dtype,\n",
            "\u001b[36mFile \u001b[39m\u001b[32m~/viral-posts-env/.venv/lib/python3.14/site-packages/transformers/models/auto/auto_factory.py:394\u001b[39m, in \u001b[36m_BaseAutoModelClass.from_pretrained\u001b[39m\u001b[34m(cls, pretrained_model_name_or_path, *model_args, **kwargs)\u001b[39m\n\u001b[32m    392\u001b[39m         \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(parent_config, \u001b[33m\"\u001b[39m\u001b[33mquantization_config\u001b[39m\u001b[33m\"\u001b[39m):\n\u001b[32m    393\u001b[39m             config.quantization_config = parent_config.quantization_config\n\u001b[32m--> \u001b[39m\u001b[32m394\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[30;43mmodel_class\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mfrom_pretrained\u001b[39;49m\u001b[30;43m(\u001b[39;49m\n\u001b[32m    395\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mpretrained_model_name_or_path\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mmodel_args\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mconfig\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mconfig\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mhub_kwargs\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mkwargs\u001b[39;49m\n\u001b[32m    396\u001b[39m \u001b[30;43m    \u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m    397\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m    398\u001b[39m     \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mUnrecognized configuration class \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mconfig.\u001b[34m__class__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m for this kind of AutoModel: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mcls\u001b[39m.\u001b[34m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m.\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[33m\"\u001b[39m\n\u001b[32m    399\u001b[39m     \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mModel type should be one of \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[33m'\u001b[39m\u001b[33m, \u001b[39m\u001b[33m'\u001b[39m.join(c.\u001b[34m__name__\u001b[39m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mfor\u001b[39;00m\u001b[38;5;250m \u001b[39mc\u001b[38;5;250m \u001b[39m\u001b[38;5;129;01min\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28mcls\u001b[39m._model_mapping)\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m    400\u001b[39m )\n",
            "\u001b[36mFile \u001b[39m\u001b[32m~/viral-posts-env/.venv/lib/python3.14/site-packages/transformers/modeling_utils.py:4118\u001b[39m, in \u001b[36mPreTrainedModel.from_pretrained\u001b[39m\u001b[34m(cls, pretrained_model_name_or_path, config, cache_dir, ignore_mismatched_sizes, force_download, local_files_only, token, revision, use_safetensors, weights_only, fusion_config, disable_mmap, *model_args, **kwargs)\u001b[39m\n\u001b[32m   4113\u001b[39m     logger.warning_once(\n\u001b[32m   4114\u001b[39m         \u001b[33m\"\u001b[39m\u001b[33mA kernel_config was provided but use_kernels is False; setting use_kernels=True automatically. To suppress this warning, explicitly set use_kernels to True.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m   4115\u001b[39m     )\n\u001b[32m   4116\u001b[39m     use_kernels = \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m4118\u001b[39m checkpoint_files, sharded_metadata = \u001b[30;43m_get_resolved_checkpoint_files\u001b[39;49m\u001b[30;43m(\u001b[39;49m\n\u001b[32m   4119\u001b[39m \u001b[30;43m    \u001b[39;49m\u001b[30;43mpretrained_model_name_or_path\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mpretrained_model_name_or_path\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   4120\u001b[39m \u001b[30;43m    \u001b[39;49m\u001b[30;43mvariant\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mvariant\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   4121\u001b[39m \u001b[30;43m    \u001b[39;49m\u001b[30;43mgguf_file\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mgguf_file\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   4122\u001b[39m \u001b[30;43m    \u001b[39;49m\u001b[30;43muse_safetensors\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43muse_safetensors\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   4123\u001b[39m \u001b[30;43m    \u001b[39;49m\u001b[30;43mdownload_kwargs\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mdownload_kwargs_with_commit\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   4124\u001b[39m \u001b[30;43m    \u001b[39;49m\u001b[30;43muser_agent\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43muser_agent\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   4125\u001b[39m \u001b[30;43m    \u001b[39;49m\u001b[30;43mis_remote_code\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mcls\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mis_remote_code\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43m)\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   4126\u001b[39m \u001b[30;43m    \u001b[39;49m\u001b[30;43mtransformers_explicit_filename\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mgetattr\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mconfig\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m\"\u001b[39;49m\u001b[30;43mtransformers_weights\u001b[39;49m\u001b[30;43m\"\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43;01mNone\u001b[39;49;00m\u001b[30;43m)\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   4127\u001b[39m \u001b[30;43m    \u001b[39;49m\u001b[30;43mtqdm_class\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mtqdm_class\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   4128\u001b[39m \u001b[30;43m\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m   4130\u001b[39m is_quantized = hf_quantizer \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m   4132\u001b[39m \u001b[38;5;66;03m# Find the correct dtype based on current state\u001b[39;00m\n",
            "\u001b[36mFile \u001b[39m\u001b[32m~/viral-posts-env/.venv/lib/python3.14/site-packages/transformers/modeling_utils.py:660\u001b[39m, in \u001b[36m_get_resolved_checkpoint_files\u001b[39m\u001b[34m(pretrained_model_name_or_path, variant, gguf_file, use_safetensors, user_agent, is_remote_code, transformers_explicit_filename, download_kwargs, tqdm_class)\u001b[39m\n\u001b[32m    648\u001b[39m can_auto_convert = (\n\u001b[32m    649\u001b[39m     \u001b[38;5;129;01mnot\u001b[39;00m is_offline_mode()  \u001b[38;5;66;03m# for obvious reasons\u001b[39;00m\n\u001b[32m    650\u001b[39m     \u001b[38;5;66;03m# If we are in a CI environment or in a pytest run, we prevent the conversion\u001b[39;00m\n\u001b[32m   (...)\u001b[39m\u001b[32m    653\u001b[39m     \u001b[38;5;129;01mand\u001b[39;00m subfolder == \u001b[33m\"\u001b[39m\u001b[33m\"\u001b[39m  \u001b[38;5;66;03m# converter bot does not work on subfolders\u001b[39;00m\n\u001b[32m    654\u001b[39m )\n\u001b[32m    656\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m    657\u001b[39m     \u001b[38;5;66;03m# Load from URL or cache if already cached\u001b[39;00m\n\u001b[32m    658\u001b[39m     \u001b[38;5;66;03m# Since we set _raise_exceptions_for_missing_entries=False, we don't get an exception but a None\u001b[39;00m\n\u001b[32m    659\u001b[39m     \u001b[38;5;66;03m# result when internet is up, the repo and revision exist, but the file does not.\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m660\u001b[39m     resolved_archive_file = \u001b[30;43mcached_file\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mpretrained_model_name_or_path\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mfilename\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mcached_file_kwargs\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m    662\u001b[39m     \u001b[38;5;66;03m# Try safetensors files first if not already found\u001b[39;00m\n\u001b[32m    663\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m resolved_archive_file \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m filename == _add_variant(SAFE_WEIGHTS_NAME, variant):\n\u001b[32m    664\u001b[39m         \u001b[38;5;66;03m# Maybe the checkpoint is sharded, we try to grab the index name in this case.\u001b[39;00m\n",
            "\u001b[36mFile \u001b[39m\u001b[32m~/viral-posts-env/.venv/lib/python3.14/site-packages/transformers/utils/hub.py:278\u001b[39m, in \u001b[36mcached_file\u001b[39m\u001b[34m(path_or_repo_id, filename, **kwargs)\u001b[39m\n\u001b[32m    223\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mcached_file\u001b[39m(\n\u001b[32m    224\u001b[39m     path_or_repo_id: \u001b[38;5;28mstr\u001b[39m | os.PathLike,\n\u001b[32m    225\u001b[39m     filename: \u001b[38;5;28mstr\u001b[39m,\n\u001b[32m    226\u001b[39m     **kwargs,\n\u001b[32m    227\u001b[39m ) -> \u001b[38;5;28mstr\u001b[39m | \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m    228\u001b[39m \u001b[38;5;250m    \u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m    229\u001b[39m \u001b[33;03m    Tries to locate a file in a local folder and repo, downloads and cache it if necessary.\u001b[39;00m\n\u001b[32m    230\u001b[39m \n\u001b[32m   (...)\u001b[39m\u001b[32m    276\u001b[39m \u001b[33;03m    ```\u001b[39;00m\n\u001b[32m    277\u001b[39m \u001b[33;03m    \"\"\"\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m278\u001b[39m     file = \u001b[30;43mcached_files\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mpath_or_repo_id\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mpath_or_repo_id\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mfilenames\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43m[\u001b[39;49m\u001b[30;43mfilename\u001b[39;49m\u001b[30;43m]\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mkwargs\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m    279\u001b[39m     file = file[\u001b[32m0\u001b[39m] \u001b[38;5;28;01mif\u001b[39;00m file \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m file\n\u001b[32m    280\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m file\n",
            "\u001b[36mFile \u001b[39m\u001b[32m~/viral-posts-env/.venv/lib/python3.14/site-packages/transformers/utils/hub.py:422\u001b[39m, in \u001b[36mcached_files\u001b[39m\u001b[34m(path_or_repo_id, filenames, cache_dir, force_download, proxies, token, revision, local_files_only, subfolder, repo_type, user_agent, _raise_exceptions_for_gated_repo, _raise_exceptions_for_missing_entries, _raise_exceptions_for_connection_errors, _commit_hash, tqdm_class, **deprecated_kwargs)\u001b[39m\n\u001b[32m    419\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m    420\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(full_filenames) == \u001b[32m1\u001b[39m:\n\u001b[32m    421\u001b[39m         \u001b[38;5;66;03m# This is slightly better for only 1 file\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m422\u001b[39m         \u001b[30;43mhf_hub_download\u001b[39;49m\u001b[30;43m(\u001b[39;49m\n\u001b[32m    423\u001b[39m \u001b[30;43m            \u001b[39;49m\u001b[30;43mpath_or_repo_id\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m    424\u001b[39m \u001b[30;43m            \u001b[39;49m\u001b[30;43mfilenames\u001b[39;49m\u001b[30;43m[\u001b[39;49m\u001b[30;43m0\u001b[39;49m\u001b[30;43m]\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m    425\u001b[39m \u001b[30;43m            \u001b[39;49m\u001b[30;43msubfolder\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43;01mNone\u001b[39;49;00m\u001b[30;43m \u001b[39;49m\u001b[30;43;01mif\u001b[39;49;00m\u001b[30;43m \u001b[39;49m\u001b[30;43mlen\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43msubfolder\u001b[39;49m\u001b[30;43m)\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m==\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m0\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43;01melse\u001b[39;49;00m\u001b[30;43m \u001b[39;49m\u001b[30;43msubfolder\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m    426\u001b[39m \u001b[30;43m            \u001b[39;49m\u001b[30;43mrepo_type\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mrepo_type\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m    427\u001b[39m \u001b[30;43m            \u001b[39;49m\u001b[30;43mrevision\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mrevision\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m    428\u001b[39m \u001b[30;43m            \u001b[39;49m\u001b[30;43mcache_dir\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mcache_dir\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m    429\u001b[39m \u001b[30;43m            \u001b[39;49m\u001b[30;43muser_agent\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43muser_agent\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m    430\u001b[39m \u001b[30;43m            \u001b[39;49m\u001b[30;43mforce_download\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mforce_download\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m    431\u001b[39m \u001b[30;43m            \u001b[39;49m\u001b[30;43mproxies\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mproxies\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m    432\u001b[39m \u001b[30;43m            \u001b[39;49m\u001b[30;43mtoken\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mtoken\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m    433\u001b[39m \u001b[30;43m            \u001b[39;49m\u001b[30;43mlocal_files_only\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mlocal_files_only\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m    434\u001b[39m \u001b[30;43m            \u001b[39;49m\u001b[30;43mtqdm_class\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mtqdm_class\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m    435\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m    436\u001b[39m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m    437\u001b[39m         snapshot_download(\n\u001b[32m    438\u001b[39m             path_or_repo_id,\n\u001b[32m    439\u001b[39m             allow_patterns=full_filenames,\n\u001b[32m   (...)\u001b[39m\u001b[32m    448\u001b[39m             tqdm_class=tqdm_class,\n\u001b[32m    449\u001b[39m         )\n",
            "\u001b[36mFile \u001b[39m\u001b[32m~/viral-posts-env/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_validators.py:88\u001b[39m, in \u001b[36mvalidate_hf_hub_args.<locals>._inner_fn\u001b[39m\u001b[34m(*args, **kwargs)\u001b[39m\n\u001b[32m     84\u001b[39m         validate_repo_id(arg_value)\n\u001b[32m     86\u001b[39m kwargs = smoothly_deprecate_legacy_arguments(fn_name=fn.\u001b[34m__name__\u001b[39m, kwargs=kwargs)\n\u001b[32m---> \u001b[39m\u001b[32m88\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[30;43mfn\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43margs\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mkwargs\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n",
            "\u001b[36mFile \u001b[39m\u001b[32m~/viral-posts-env/.venv/lib/python3.14/site-packages/huggingface_hub/file_download.py:995\u001b[39m, in \u001b[36mhf_hub_download\u001b[39m\u001b[34m(repo_id, filename, subfolder, repo_type, revision, library_name, library_version, cache_dir, local_dir, user_agent, force_download, etag_timeout, token, local_files_only, headers, endpoint, tqdm_class, dry_run)\u001b[39m\n\u001b[32m    974\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m _hf_hub_download_to_local_dir(\n\u001b[32m    975\u001b[39m         \u001b[38;5;66;03m# Destination\u001b[39;00m\n\u001b[32m    976\u001b[39m         local_dir=local_dir,\n\u001b[32m   (...)\u001b[39m\u001b[32m    992\u001b[39m         dry_run=dry_run,\n\u001b[32m    993\u001b[39m     )\n\u001b[32m    994\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m995\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[30;43m_hf_hub_download_to_cache_dir\u001b[39;49m\u001b[30;43m(\u001b[39;49m\n\u001b[32m    996\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43;03m# Destination\u001b[39;49;00m\n\u001b[32m    997\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mcache_dir\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mcache_dir\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m    998\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43;03m# File info\u001b[39;49;00m\n\u001b[32m    999\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mrepo_id\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mrepo_id\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   1000\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mfilename\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mfilename\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   1001\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mrepo_type\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mrepo_type\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   1002\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mrevision\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mrevision\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   1003\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43;03m# HTTP info\u001b[39;49;00m\n\u001b[32m   1004\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mendpoint\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mendpoint\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   1005\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43metag_timeout\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43metag_timeout\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   1006\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mheaders\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mhf_headers\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   1007\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mtoken\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mtoken\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   1008\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43;03m# Additional options\u001b[39;49;00m\n\u001b[32m   1009\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mlocal_files_only\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mlocal_files_only\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   1010\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mforce_download\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mforce_download\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   1011\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mtqdm_class\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mtqdm_class\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   1012\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mdry_run\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mdry_run\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   1013\u001b[39m \u001b[30;43m    \u001b[39;49m\u001b[30;43m)\u001b[39;49m\n",
            "\u001b[36mFile \u001b[39m\u001b[32m~/viral-posts-env/.venv/lib/python3.14/site-packages/huggingface_hub/file_download.py:1213\u001b[39m, in \u001b[36m_hf_hub_download_to_cache_dir\u001b[39m\u001b[34m(cache_dir, repo_id, filename, repo_type, revision, endpoint, etag_timeout, headers, token, local_files_only, force_download, tqdm_class, dry_run)\u001b[39m\n\u001b[32m   1209\u001b[39m         \u001b[38;5;28;01mreturn\u001b[39;00m pointer_path\n\u001b[32m   1211\u001b[39m \u001b[38;5;66;03m# Local file doesn't exist or etag isn't a match => retrieve file from remote (or cache)\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1213\u001b[39m \u001b[30;43m\u001b[39;49m\u001b[30;43;01mwith\u001b[39;49;00m\u001b[30;43m \u001b[39;49m\u001b[30;43mWeakFileLock\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mlock_path\u001b[39;49m\u001b[30;43m)\u001b[39;49m\u001b[30;43m:\u001b[39;49m\n\u001b[32m   1214\u001b[39m \u001b[30;43m    \u001b[39;49m\u001b[30;43m_download_to_tmp_and_move\u001b[39;49m\u001b[30;43m(\u001b[39;49m\n\u001b[32m   1215\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mincomplete_path\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mPath\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mblob_path\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m+\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m\"\u001b[39;49m\u001b[30;43m.incomplete\u001b[39;49m\u001b[30;43m\"\u001b[39;49m\u001b[30;43m)\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   1216\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mdestination_path\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mPath\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mblob_path\u001b[39;49m\u001b[30;43m)\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   (...)\u001b[39m\u001b[32m   1224\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mtqdm_class\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mtqdm_class\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m   1225\u001b[39m \u001b[30;43m    \u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m   1226\u001b[39m \u001b[30;43m    \u001b[39;49m\u001b[30;43;01mif\u001b[39;49;00m\u001b[30;43m \u001b[39;49m\u001b[30;43;01mnot\u001b[39;49;00m\u001b[30;43m \u001b[39;49m\u001b[30;43mos\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mpath\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mexists\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mpointer_path\u001b[39;49m\u001b[30;43m)\u001b[39;49m\u001b[30;43m:\u001b[39;49m\n",
            "\u001b[36mFile \u001b[39m\u001b[32m/opt/homebrew/Cellar/python@3.14/3.14.2_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/contextlib.py:141\u001b[39m, in \u001b[36m_GeneratorContextManager.__enter__\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    139\u001b[39m \u001b[38;5;28;01mdel\u001b[39;00m \u001b[38;5;28mself\u001b[39m.args, \u001b[38;5;28mself\u001b[39m.kwds, \u001b[38;5;28mself\u001b[39m.func\n\u001b[32m    140\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m141\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[30;43mnext\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mself\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mgen\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m    142\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mStopIteration\u001b[39;00m:\n\u001b[32m    143\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[33m\"\u001b[39m\u001b[33mgenerator didn\u001b[39m\u001b[33m'\u001b[39m\u001b[33mt yield\u001b[39m\u001b[33m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m\n",
            "\u001b[36mFile \u001b[39m\u001b[32m~/viral-posts-env/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_fixes.py:99\u001b[39m, in \u001b[36mWeakFileLock\u001b[39m\u001b[34m(lock_file, timeout)\u001b[39m\n\u001b[32m     96\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m Timeout(\u001b[38;5;28mstr\u001b[39m(lock_file))\n\u001b[32m     98\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m---> \u001b[39m\u001b[32m99\u001b[39m     \u001b[30;43mlock\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43macquire\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mtimeout\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mmin\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mlog_interval\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mtimeout\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m-\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43melapsed_time\u001b[39;49m\u001b[30;43m)\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43;01mif\u001b[39;49;00m\u001b[30;43m \u001b[39;49m\u001b[30;43mtimeout\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43;01melse\u001b[39;49;00m\u001b[30;43m \u001b[39;49m\u001b[30;43mlog_interval\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m    100\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m Timeout:\n\u001b[32m    101\u001b[39m     logger.info(\n\u001b[32m    102\u001b[39m         \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mStill waiting to acquire lock on \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mlock_file\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m (elapsed: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtime.time()\u001b[38;5;250m \u001b[39m-\u001b[38;5;250m \u001b[39mstart_time\u001b[38;5;132;01m:\u001b[39;00m\u001b[33m.1f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m seconds)\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m    103\u001b[39m     )\n",
            "\u001b[36mFile \u001b[39m\u001b[32m~/viral-posts-env/.venv/lib/python3.14/site-packages/filelock/_api.py:513\u001b[39m, in \u001b[36mBaseFileLock.acquire\u001b[39m\u001b[34m(self, timeout, poll_interval, poll_intervall, blocking, cancel_check)\u001b[39m\n\u001b[32m    511\u001b[39m         msg = \u001b[33m\"\u001b[39m\u001b[33mLock \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[33m not acquired on \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[33m, waiting \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[33m seconds ...\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m    512\u001b[39m         _LOGGER.debug(msg, lock_id, lock_filename, poll_interval)\n\u001b[32m--> \u001b[39m\u001b[32m513\u001b[39m         \u001b[30;43mtime\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43msleep\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mpoll_interval\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m    514\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mBaseException\u001b[39;00m:\n\u001b[32m    515\u001b[39m     \u001b[38;5;28mself\u001b[39m._context.lock_counter = \u001b[38;5;28mmax\u001b[39m(\u001b[32m0\u001b[39m, \u001b[38;5;28mself\u001b[39m._context.lock_counter - \u001b[32m1\u001b[39m)\n",
            "\u001b[31mKeyboardInterrupt\u001b[39m: "
          ]
        }
      ],
      "source": [
        "# Cell 7: Load model (4-bit on CUDA Colab; fp16/fp32 fallback if bitsandbytes missing)\n",
        "from transformers import AutoTokenizer, AutoModelForCausalLM\n",
        "\n",
        "MODEL_NAME = \"Qwen/Qwen2.5-1.5B-Instruct\"\n",
        "\n",
        "tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)\n",
        "\n",
        "_use_4bit = False\n",
        "try:\n",
        "    from transformers.utils import is_bitsandbytes_available\n",
        "except Exception:  # older transformers\n",
        "    def is_bitsandbytes_available():\n",
        "        try:\n",
        "            import bitsandbytes  # noqa: F401\n",
        "            return True\n",
        "        except ImportError:\n",
        "            return False\n",
        "\n",
        "if torch.cuda.is_available() and is_bitsandbytes_available():\n",
        "    from transformers import BitsAndBytesConfig\n",
        "    _use_4bit = True\n",
        "\n",
        "if _use_4bit:\n",
        "    print(f\"Loading {MODEL_NAME} (4-bit quantized, CUDA)...\")\n",
        "    bnb_config = BitsAndBytesConfig(\n",
        "        load_in_4bit=True,\n",
        "        bnb_4bit_quant_type=\"nf4\",\n",
        "        bnb_4bit_compute_dtype=torch.float16,\n",
        "        bnb_4bit_use_double_quant=True,\n",
        "    )\n",
        "    model = AutoModelForCausalLM.from_pretrained(\n",
        "        MODEL_NAME,\n",
        "        trust_remote_code=True,\n",
        "        quantization_config=bnb_config,\n",
        "        device_map=\"auto\",\n",
        "    )\n",
        "else:\n",
        "    print(\n",
        "        f\"Loading {MODEL_NAME} without 4-bit (bitsandbytes/CUDA unavailable).\\n\"\n",
        "        \"  On Colab: run `pip install -U bitsandbytes>=0.46.1` and use a GPU runtime.\\n\"\n",
        "        \"  On Mac: use fp16 on MPS or fp32 on CPU.\"\n",
        "    )\n",
        "    dtype = torch.float16 if (torch.cuda.is_available() or getattr(torch.backends, \"mps\", None) and torch.backends.mps.is_available()) else torch.float32\n",
        "    model = AutoModelForCausalLM.from_pretrained(\n",
        "        MODEL_NAME,\n",
        "        trust_remote_code=True,\n",
        "        dtype=dtype,\n",
        "        device_map=\"auto\" if torch.cuda.is_available() else None,\n",
        "    )\n",
        "    if not torch.cuda.is_available():\n",
        "        if getattr(torch.backends, \"mps\", None) and torch.backends.mps.is_available():\n",
        "            model = model.to(\"mps\")\n",
        "        else:\n",
        "            model = model.to(\"cpu\")\n",
        "\n",
        "model.eval()\n",
        "print(f\"Model loaded. dtype={next(model.parameters()).dtype}\")\n",
        "try:\n",
        "    print(f\"Device: {model.device}\")\n",
        "except Exception:\n",
        "    print(\"Device: (see first parameter device)\")\n",
        "if torch.cuda.is_available():\n",
        "    print(f\"CUDA memory: {torch.cuda.memory_allocated()/1e9:.2f} GB\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Cell 8: LLM agent functions\n",
        "SYSTEM_PROMPT = textwrap.dedent(\"\"\"\\\n",
        "You are an Instagram content strategy agent. Each step is one day.\n",
        "You manage a creator account over a 30-day cycle.\n",
        "\n",
        "RESPONSE FORMAT — return ONLY valid JSON, no markdown:\n",
        "{\n",
        "  \"tool_calls\": [{\"name\": \"<tool>\", \"arguments\": {...}}],\n",
        "  \"scheduled_actions\": [\n",
        "    {\"hour\": 0-23, \"action_type\": \"post|create_content\",\n",
        "     \"content_type\": \"reel|story|carousel|text_post\",\n",
        "     \"topic\": \"<string>\", \"tags\": [\"...\"],\n",
        "     \"intent\": \"send_bait|save_bait|watch_bait|like_bait\"}\n",
        "  ],\n",
        "  \"notes\": \"strategy notes\"\n",
        "}\n",
        "\n",
        "TOOLS (cost in API budget, total=100):\n",
        "- query_trends(niche)                            cost=1  trending topics+tags for niche\n",
        "- query_audience(segment_id)                     cost=2  segment topic affinities + active hours\n",
        "- query_competitor(competitor_id, window_days)   cost=2  competitor recent posts\n",
        "- query_tag_history(tag)                         cost=1  your past signals (watch/sends/saves/likes) for a tag\n",
        "- predict_engagement(scheduled_actions)          cost=3  simulate a plan WITHOUT committing\n",
        "- draft_review(scheduled_actions)                cost=3  AI review of a draft plan\n",
        "- query_creator_pool()                           cost=1  list collab partners with audience overlap\n",
        "- propose_collab(partner_id, content_type, hour) cost=5  co-author the post at that hour (max 2/month)\n",
        "\n",
        "ACTION SCHEMA:\n",
        "- hour:         0..23 (unlisted hours = rest)\n",
        "- action_type:  post (publish) | create_content (build queue, no publish)\n",
        "- content_type: reel | story | carousel | text_post\n",
        "- intent:       which Mosseri signal the post optimises for\n",
        "                  send_bait  -> DM shares (strongest discovery signal)\n",
        "                  save_bait  -> bookmarks (content quality)\n",
        "                  watch_bait -> reels watch time\n",
        "                  like_bait  -> likes from existing followers\n",
        "- tags:         up to 5 hashtags\n",
        "- topic:        free-form string\n",
        "- empty scheduled_actions = full day rest\"\"\")\n",
        "\n",
        "\n",
        "def format_obs(obs):\n",
        "    days = [\"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\", \"Sun\"]\n",
        "    day_name = days[obs.day_of_week] if 0 <= obs.day_of_week < 7 else \"?\"\n",
        "    signals_str = \"\"\n",
        "    signals = getattr(obs, \"engagement_signals\", None)\n",
        "    if signals:\n",
        "        signals_str = (f\"Signals: watch={signals.watch_time:.3f} \"\n",
        "                       f\"sends={signals.sends_per_reach:.3f} \"\n",
        "                       f\"saves={signals.saves:.3f}\\n\")\n",
        "    tool_str = \"\"\n",
        "    for tr in getattr(obs, \"tool_results\", []):\n",
        "        if tr.success:\n",
        "            tool_str += f\"  {tr.name}: {json.dumps(tr.data)}\\n\"\n",
        "    if not tool_str:\n",
        "        tool_str = \"  (none)\\n\"\n",
        "    return (f\"Day: {day_name} | days_elapsed={obs.days_elapsed}\\n\"\n",
        "            f\"Energy: {obs.creator_energy:.2f} | Followers: {obs.follower_count}\\n\"\n",
        "            f\"Engagement: {obs.engagement_rate:.3f} | Queue: {obs.content_queue_size}\\n\"\n",
        "            f\"{signals_str}\"\n",
        "            f\"Tool results:\\n{tool_str}\"\n",
        "            f\"Plan your actions (JSON only):\")\n",
        "\n",
        "\n",
        "def is_well_formed_response(text):\n",
        "    try:\n",
        "        t = text.strip()\n",
        "        if \"```\" in t:\n",
        "            t = \"\\n\".join(l for l in t.split(\"\\n\") if not l.strip().startswith(\"```\")).strip()\n",
        "        s, e = t.find(\"{\"), t.rfind(\"}\") + 1\n",
        "        d = json.loads(t[s:e])\n",
        "        for tc in d.get(\"tool_calls\", []):\n",
        "            if not isinstance(tc, dict) or not isinstance(tc.get(\"arguments\", {}), dict):\n",
        "                return False\n",
        "        return True\n",
        "    except Exception:\n",
        "        return False\n",
        "\n",
        "\n",
        "def parse_model_output(text):\n",
        "    text = text.strip()\n",
        "    if \"```\" in text:\n",
        "        lines = [l for l in text.split(\"\\n\") if not l.strip().startswith(\"```\")]\n",
        "        text = \"\\n\".join(lines).strip()\n",
        "    start, end = text.find(\"{\"), text.rfind(\"}\") + 1\n",
        "    if start >= 0 and end > start:\n",
        "        text = text[start:end]\n",
        "    try:\n",
        "        data = json.loads(text)\n",
        "    except Exception:\n",
        "        return ViraltestAction(scheduled_actions=[])\n",
        "    tool_calls = []\n",
        "    for tc in data.get(\"tool_calls\", []):\n",
        "        if not isinstance(tc, dict) or \"name\" not in tc:\n",
        "            continue\n",
        "        args = tc.get(\"arguments\", {})\n",
        "        if isinstance(args, list) and args and isinstance(args[0], dict):\n",
        "            args = args[0]\n",
        "        if not isinstance(args, dict):\n",
        "            continue\n",
        "        try:\n",
        "            tool_calls.append(ToolCall(name=tc[\"name\"], arguments=args))\n",
        "        except Exception:\n",
        "            pass\n",
        "    scheduled = []\n",
        "    for a in data.get(\"scheduled_actions\", []):\n",
        "        try:\n",
        "            scheduled.append(ScheduledAction(**a))\n",
        "        except Exception:\n",
        "            pass\n",
        "    return ViraltestAction(\n",
        "        tool_calls=tool_calls,\n",
        "        scheduled_actions=scheduled,\n",
        "        notes=data.get(\"notes\"),\n",
        "    )\n",
        "\n",
        "\n",
        "def _infer_model_device(m):\n",
        "    \"\"\"Works for single/multi-device models (Peft, 4-bit) where m.device may be missing.\"\"\"\n",
        "    p = next(m.parameters(), None)\n",
        "    if p is not None:\n",
        "        return p.device\n",
        "    d = getattr(m, \"device\", None)\n",
        "    if d is not None:\n",
        "        return d\n",
        "    return torch.device(\"cpu\")\n",
        "\n",
        "\n",
        "def generate_action(mdl, tok, obs, history, temperature=0.7, debug=True):\n",
        "    prompt = format_obs(obs)\n",
        "    messages = [{\"role\": \"system\", \"content\": SYSTEM_PROMPT}]\n",
        "    messages.extend(history[-14:])\n",
        "    messages.append({\"role\": \"user\", \"content\": prompt})\n",
        "    text_input = tok.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
        "    inputs = tok(text_input, return_tensors=\"pt\").to(_infer_model_device(mdl))\n",
        "    with torch.no_grad():\n",
        "        out = mdl.generate(**inputs, max_new_tokens=512, temperature=temperature,\n",
        "                           do_sample=True, top_p=0.9, pad_token_id=tok.eos_token_id)\n",
        "    resp = tok.decode(out[0][inputs[\"input_ids\"].shape[1]:], skip_special_tokens=True)\n",
        "    if debug:\n",
        "        print(\"=\" * 60)\n",
        "        print(f\"[LLM PROMPT] tokens={inputs['input_ids'].shape[1]}\")\n",
        "        print(prompt)\n",
        "        print(\"-\" * 60)\n",
        "        print(f\"[LLM RESPONSE] tokens={out.shape[1] - inputs['input_ids'].shape[1]}\")\n",
        "        print(resp)\n",
        "        print(\"=\" * 60)\n",
        "    return resp, parse_model_output(resp)\n",
        "\n",
        "\n",
        "def run_llm_episode(mdl, tok, task, seed=42, verbose=False, debug_llm=True):\n",
        "    env = ViraltestEnvironment()\n",
        "    obs = env.reset(task=task, seed=seed)\n",
        "    rewards, energies = [], [obs.creator_energy]\n",
        "    history, pairs = [], []\n",
        "    for day in range(1, TASK_HORIZON + 1):\n",
        "        if obs.done: break\n",
        "        if debug_llm:\n",
        "            print(f\"\\n>>> Day {day} | task={task} | energy={obs.creator_energy:.2f}\")\n",
        "        resp, action = generate_action(mdl, tok, obs, history, debug=debug_llm)\n",
        "        prompt = format_obs(obs)\n",
        "        pairs.append({\"prompt\": prompt, \"response\": resp})\n",
        "        obs = env.step(action)\n",
        "        r = obs.reward or 0.0\n",
        "        rewards.append(r)\n",
        "        energies.append(obs.creator_energy)\n",
        "        history.extend([{\"role\": \"user\", \"content\": prompt},\n",
        "                        {\"role\": \"assistant\", \"content\": resp}])\n",
        "        if verbose:\n",
        "            n_p = len([s for s in action.scheduled_actions if s.action_type==\"post\"])\n",
        "            print(f\"    Day {day:2d}: r={r:.4f} e={obs.creator_energy:.2f} posts={n_p} tools={len(action.tool_calls)}\")\n",
        "        if obs.done: break\n",
        "    gs = (obs.metadata or {}).get(\"grader_score\", 0.0)\n",
        "    # Per-step credit assignment: G_t = r_t + gamma * G_{t+1}, terminal = grader_score * w\n",
        "    GAMMA, TERMINAL_W = 0.95, 5.0\n",
        "    G, returns = gs * TERMINAL_W, [0.0] * len(rewards)\n",
        "    for t in reversed(range(len(rewards))):\n",
        "        G = rewards[t] + GAMMA * G\n",
        "        returns[t] = G\n",
        "    for i, pr in enumerate(pairs):\n",
        "        pr[\"return\"] = returns[i] if i < len(returns) else 0.0\n",
        "    return {\"task\": task, \"grader_score\": gs, \"total_reward\": sum(rewards),\n",
        "            \"final_energy\": obs.creator_energy, \"rewards\": rewards,\n",
        "            \"returns\": returns, \"energies\": energies, \"pairs\": pairs,\n",
        "            \"follower_delta\": obs.follower_count - 10000,\n",
        "            \"burned_out\": obs.creator_energy <= 0}\n",
        "\n",
        "print(\"LLM agent functions defined.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Part 3: Untrained LLM Baseline (“Before”)\n",
        "\n",
        "Run the base model with NO fine-tuning. This establishes ground truth."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Cell 9: Run untrained model\n",
        "print(\"Running UNTRAINED base model on all tasks...\")\n",
        "print(\"=\" * 60)\n",
        "\n",
        "before_results = {}\n",
        "for task in TASKS:\n",
        "    print(f\"\\n  Task: {task}\")\n",
        "    result = run_llm_episode(model, tokenizer, task, seed=42, verbose=True)\n",
        "    before_results[task] = result\n",
        "    print(f\"  => grader={result['grader_score']:.4f} reward={result['total_reward']:.3f}\")\n",
        "\n",
        "print(\"\\n\" + \"=\" * 60)\n",
        "print(\"BEFORE TRAINING:\")\n",
        "for t in TASKS:\n",
        "    print(f\"  {t}: grader={before_results[t]['grader_score']:.4f}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Part 4: LoRA Fine-Tuning (Real Weight Updates)\n",
        "\n",
        "This is the core training loop. For each round:\n",
        "1. Collect episodes with current model\n",
        "2. Score each (prompt, response) pair by episode reward\n",
        "3. Keep top 50% highest-reward samples\n",
        "4. Fine-tune LoRA weights via SFT on those samples\n",
        "\n",
        "The model's actual weights change via gradient descent — this is real training."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Cell 10: Attach LoRA adapter\n",
        "from peft import LoraConfig, get_peft_model, TaskType\n",
        "\n",
        "lora_config = LoraConfig(\n",
        "    r=16, lora_alpha=32, lora_dropout=0.05,\n",
        "    target_modules=[\"q_proj\", \"k_proj\", \"v_proj\", \"o_proj\",\n",
        "                    \"gate_proj\", \"up_proj\", \"down_proj\"],\n",
        "    task_type=TaskType.CAUSAL_LM, bias=\"none\",\n",
        ")\n",
        "\n",
        "model.enable_input_require_grads()\n",
        "peft_model = get_peft_model(model, lora_config)\n",
        "peft_model.print_trainable_parameters()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Cell 11: Training loop\n",
        "from trl import SFTTrainer, SFTConfig\n",
        "from datasets import Dataset\n",
        "\n",
        "NUM_ROUNDS = 4\n",
        "EPISODES_PER_ROUND = 6\n",
        "TOP_K_FRACTION = 0.5\n",
        "\n",
        "training_log = {\n",
        "    \"round\": [], \"avg_episode_reward\": [], \"max_episode_reward\": [],\n",
        "    \"min_episode_reward\": [], \"avg_grader\": [], \"max_grader\": [],\n",
        "    \"n_training_samples\": [], \"train_loss\": [],\n",
        "}\n",
        "\n",
        "t_start = time.time()\n",
        "\n",
        "for round_idx in range(1, NUM_ROUNDS + 1):\n",
        "    print(f\"\\n{'=' * 60}\")\n",
        "    print(f\"TRAINING ROUND {round_idx}/{NUM_ROUNDS}\")\n",
        "    print(f\"{'=' * 60}\")\n",
        "\n",
        "    # Collect episodes\n",
        "    peft_model.eval()\n",
        "    all_pairs, episode_rewards, episode_graders = [], [], []\n",
        "\n",
        "    for ep in range(EPISODES_PER_ROUND):\n",
        "        task = TASKS[ep % len(TASKS)]\n",
        "        seed = 42 + (round_idx - 1) * 100 + ep\n",
        "        result = run_llm_episode(peft_model, tokenizer, task, seed=seed)\n",
        "        ep_reward = result[\"total_reward\"] + 2.0 * result[\"grader_score\"]\n",
        "        episode_rewards.append(ep_reward)\n",
        "        episode_graders.append(result[\"grader_score\"])\n",
        "\n",
        "        for pr in result[\"pairs\"]:\n",
        "            if not is_well_formed_response(pr[\"response\"]):\n",
        "                continue\n",
        "            text = (f\"<|im_start|>system\\n{SYSTEM_PROMPT}<|im_end|>\\n\"\n",
        "                    f\"<|im_start|>user\\n{pr['prompt']}<|im_end|>\\n\"\n",
        "                    f\"<|im_start|>assistant\\n{pr['response']}<|im_end|>\")\n",
        "            all_pairs.append({\"text\": text, \"reward\": pr[\"return\"]})\n",
        "\n",
        "        rets = result[\"returns\"]\n",
        "        print(f\"  ep {ep+1}/{EPISODES_PER_ROUND}: {task.split('_')[-1]:>11s} \"\n",
        "              f\"grader={result['grader_score']:.4f} reward={ep_reward:.3f} \"\n",
        "              f\"return[min={min(rets):.2f} max={max(rets):.2f} mean={np.mean(rets):.2f}]\")\n",
        "\n",
        "    avg_r = np.mean(episode_rewards)\n",
        "    avg_g = np.mean(episode_graders)\n",
        "    print(f\"  Avg reward={avg_r:.3f} Avg grader={avg_g:.4f}\")\n",
        "\n",
        "    # Filter to top-K by per-pair return (per-step credit assignment)\n",
        "    threshold = np.percentile([p[\"reward\"] for p in all_pairs], (1 - TOP_K_FRACTION) * 100)\n",
        "    filtered = [p for p in all_pairs if p[\"reward\"] >= threshold] or all_pairs\n",
        "    print(f\"  Filtered to {len(filtered)}/{len(all_pairs)} samples (return >= {threshold:.3f})\")\n",
        "\n",
        "    dataset = Dataset.from_list([{\"text\": p[\"text\"]} for p in filtered])\n",
        "\n",
        "    # SFT training (real gradient updates)\n",
        "    sft_config = SFTConfig(\n",
        "        output_dir=f\"./checkpoints/round_{round_idx}\",\n",
        "        max_steps=7,\n",
        "        per_device_train_batch_size=32,\n",
        "        gradient_accumulation_steps=1,\n",
        "        learning_rate=2e-5,\n",
        "        warmup_ratio=0.1,\n",
        "        logging_steps=1,\n",
        "        save_strategy=\"no\",\n",
        "        max_length=4096,\n",
        "        bf16=True,\n",
        "        gradient_checkpointing=False,\n",
        "        dataloader_num_workers=4,\n",
        "        dataloader_pin_memory=True,\n",
        "        optim=\"adamw_torch_fused\",\n",
        "        report_to=\"none\",\n",
        "    )\n",
        "\n",
        "    peft_model.train()\n",
        "    trainer = SFTTrainer(\n",
        "        model=peft_model, processing_class=tokenizer,\n",
        "        train_dataset=dataset, args=sft_config,\n",
        "    )\n",
        "    train_result = trainer.train()\n",
        "    loss = train_result.training_loss\n",
        "    print(f\"  Training loss: {loss:.4f}\")\n",
        "\n",
        "    training_log[\"round\"].append(round_idx)\n",
        "    training_log[\"avg_episode_reward\"].append(round(float(avg_r), 3))\n",
        "    training_log[\"max_episode_reward\"].append(round(float(max(episode_rewards)), 3))\n",
        "    training_log[\"min_episode_reward\"].append(round(float(min(episode_rewards)), 3))\n",
        "    training_log[\"avg_grader\"].append(round(float(avg_g), 4))\n",
        "    training_log[\"max_grader\"].append(round(float(max(episode_graders)), 4))\n",
        "    training_log[\"n_training_samples\"].append(len(filtered))\n",
        "    training_log[\"train_loss\"].append(round(loss, 4))\n",
        "\n",
        "elapsed = time.time() - t_start\n",
        "print(f\"\\nTraining complete in {elapsed/60:.1f} min\")\n",
        "print(pd.DataFrame(training_log).to_string(index=False))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Part 5: Trained LLM Evaluation (“After”)\n",
        "\n",
        "Same model, same seeds, same environment — but now with updated LoRA weights."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Cell 12: Run trained model\n",
        "print(\"Running TRAINED model on all tasks...\")\n",
        "print(\"=\" * 60)\n",
        "\n",
        "peft_model.eval()\n",
        "after_results = {}\n",
        "for task in TASKS:\n",
        "    print(f\"\\n  Task: {task}\")\n",
        "    result = run_llm_episode(peft_model, tokenizer, task, seed=42, verbose=True)\n",
        "    after_results[task] = result\n",
        "    print(f\"  => grader={result['grader_score']:.4f} reward={result['total_reward']:.3f}\")\n",
        "\n",
        "print(\"\\n\" + \"=\" * 60)\n",
        "print(\"AFTER TRAINING:\")\n",
        "for t in TASKS:\n",
        "    print(f\"  {t}: grader={after_results[t]['grader_score']:.4f}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Part 6: Result Plots — Real Training Evidence"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Cell 13: Training curves\n",
        "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n",
        "rounds = training_log[\"round\"]\n",
        "\n",
        "axes[0].plot(rounds, training_log[\"avg_grader\"], 'o-', color='#2196F3', lw=2, label='Avg grader')\n",
        "axes[0].fill_between(rounds, training_log[\"avg_grader\"],\n",
        "                     training_log[\"max_grader\"], alpha=0.2, color='#2196F3')\n",
        "axes[0].set_xlabel('Round'); axes[0].set_ylabel('Grader Score')\n",
        "axes[0].set_title('Grader Score Over Rounds', fontweight='bold')\n",
        "axes[0].legend(); axes[0].grid(True, alpha=0.3)\n",
        "\n",
        "axes[1].plot(rounds, training_log[\"train_loss\"], 's-', color='#E53935', lw=2)\n",
        "axes[1].set_xlabel('Round'); axes[1].set_ylabel('Loss')\n",
        "axes[1].set_title('Training Loss', fontweight='bold')\n",
        "axes[1].grid(True, alpha=0.3)\n",
        "\n",
        "fig.suptitle('Viraltest v2 — LoRA Training Progress (Qwen 1.5B)', fontsize=14, fontweight='bold')\n",
        "fig.tight_layout()\n",
        "fig.savefig(f'{PLOTS_DIR}/reward_curve.png', dpi=150, bbox_inches='tight')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Cell 14: Before vs After\n",
        "task_labels = [t.replace('monthly_', '').title() for t in TASKS]\n",
        "x = np.arange(len(TASKS))\n",
        "w = 0.25\n",
        "\n",
        "fig, ax = plt.subplots(figsize=(10, 6))\n",
        "b_scores = [before_results[t][\"grader_score\"] for t in TASKS]\n",
        "a_scores = [after_results[t][\"grader_score\"] for t in TASKS]\n",
        "s_scores = [baseline_results[\"smart\"][t][\"grader_score\"] for t in TASKS]\n",
        "\n",
        "ax.bar(x - w, b_scores, w, label='Base Model (Before)', color='#FF9800')\n",
        "ax.bar(x, a_scores, w, label='LoRA Trained (After)', color='#4CAF50')\n",
        "ax.bar(x + w, s_scores, w, label='Smart Heuristic', color='#9E9E9E', alpha=0.7)\n",
        "\n",
        "ax.set_ylabel('Grader Score'); ax.set_xticks(x); ax.set_xticklabels(task_labels)\n",
        "ax.set_title('Before vs After LoRA Training — Grader Scores', fontsize=14, fontweight='bold')\n",
        "ax.legend(); ax.grid(True, alpha=0.3, axis='y')\n",
        "\n",
        "for container in ax.containers:\n",
        "    for bar in container:\n",
        "        h = bar.get_height()\n",
        "        if h > 0:\n",
        "            ax.text(bar.get_x() + bar.get_width()/2., h + 0.005,\n",
        "                    f'{h:.4f}', ha='center', va='bottom', fontsize=9)\n",
        "\n",
        "fig.tight_layout()\n",
        "fig.savefig(f'{PLOTS_DIR}/before_after.png', dpi=150, bbox_inches='tight')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Cell 15: Trajectory comparison\n",
        "fig, axes = plt.subplots(2, 3, figsize=(16, 8))\n",
        "comparisons = [\n",
        "    (\"Base Model\", before_results, '#FF9800', '--'),\n",
        "    (\"LoRA Trained\", after_results, '#4CAF50', '-'),\n",
        "]\n",
        "for i, task in enumerate(TASKS):\n",
        "    for label, res, color, ls in comparisons:\n",
        "        lw = 2.5 if 'Trained' in label else 1.5\n",
        "        axes[0, i].plot(res[task][\"rewards\"], label=label, color=color, lw=lw, ls=ls)\n",
        "        axes[1, i].plot(res[task][\"energies\"], label=label, color=color, lw=lw, ls=ls)\n",
        "    sr = baseline_results[\"smart\"][task]\n",
        "    axes[0, i].plot(sr[\"rewards\"], label=\"Smart\", color='#9E9E9E', lw=1, ls=':')\n",
        "    axes[1, i].plot(sr[\"energies\"], label=\"Smart\", color='#9E9E9E', lw=1, ls=':')\n",
        "    t_name = task.replace('monthly_', '').title()\n",
        "    axes[0, i].set_title(f\"{t_name} — Rewards\"); axes[0, i].grid(True, alpha=0.3)\n",
        "    axes[1, i].set_title(f\"{t_name} — Energy\"); axes[1, i].grid(True, alpha=0.3)\n",
        "axes[0, 2].legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n",
        "fig.suptitle('Before vs After — Daily Trajectories', fontsize=14, fontweight='bold', y=1.01)\n",
        "fig.tight_layout()\n",
        "fig.savefig(f'{PLOTS_DIR}/training_trajectories.png', dpi=150, bbox_inches='tight')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Part 7: Summary & Export"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Cell 16: Final summary\n",
        "print(\"=\" * 67)\n",
        "print(\"FINAL RESULTS\")\n",
        "print(\"=\" * 67)\n",
        "print(f\"\\n{'Task':<25s} {'Before':>10s} {'After':>10s} {'Delta':>10s} {'Smart':>10s}\")\n",
        "print(\"-\" * 67)\n",
        "for task in TASKS:\n",
        "    b = before_results[task][\"grader_score\"]\n",
        "    a = after_results[task][\"grader_score\"]\n",
        "    s = baseline_results[\"smart\"][task][\"grader_score\"]\n",
        "    print(f\"{task:<25s} {b:>10.4f} {a:>10.4f} {a-b:>+10.4f} {s:>10.4f}\")\n",
        "\n",
        "avg_b = np.mean([before_results[t][\"grader_score\"] for t in TASKS])\n",
        "avg_a = np.mean([after_results[t][\"grader_score\"] for t in TASKS])\n",
        "avg_s = np.mean([baseline_results[\"smart\"][t][\"grader_score\"] for t in TASKS])\n",
        "print(\"-\" * 67)\n",
        "print(f\"{'AVERAGE':<25s} {avg_b:>10.4f} {avg_a:>10.4f} {avg_a-avg_b:>+10.4f} {avg_s:>10.4f}\")\n",
        "\n",
        "summary = {\n",
        "    \"model\": MODEL_NAME,\n",
        "    \"training\": \"LoRA SFT (real weight updates)\",\n",
        "    \"rounds\": NUM_ROUNDS, \"episodes_per_round\": EPISODES_PER_ROUND,\n",
        "    \"before\": {t: before_results[t][\"grader_score\"] for t in TASKS},\n",
        "    \"after\": {t: after_results[t][\"grader_score\"] for t in TASKS},\n",
        "    \"smart_heuristic\": {t: baseline_results[\"smart\"][t][\"grader_score\"] for t in TASKS},\n",
        "    \"improvement\": {t: after_results[t][\"grader_score\"] - before_results[t][\"grader_score\"] for t in TASKS},\n",
        "    \"training_log\": training_log,\n",
        "}\n",
        "with open(f\"{PLOTS_DIR}/training_summary.json\", \"w\") as f:\n",
        "    json.dump(summary, f, indent=2)\n",
        "\n",
        "pd.DataFrame(training_log).to_csv(f\"{PLOTS_DIR}/training_log.csv\", index=False)\n",
        "\n",
        "print(f\"\\nSaved to {PLOTS_DIR}/\")\n",
        "print(\"All results are from real LoRA weight updates on real environment runs.\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Cell 17: Save adapter\n",
        "save_path = \"./viraltest_trained_adapter\"\n",
        "peft_model.save_pretrained(save_path)\n",
        "tokenizer.save_pretrained(save_path)\n",
        "print(f\"LoRA adapter saved to {save_path}\")\n",
        "print(\"Load with: PeftModel.from_pretrained(base_model, save_path)\")"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": ".venv",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.13.1"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 4
}