diff --git "a/Muon.ipynb" "b/Muon.ipynb"
new file mode 100644--- /dev/null
+++ "b/Muon.ipynb"
@@ -0,0 +1,1147 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "collapsed": true,
+    "executionInfo": {
+     "elapsed": 163430,
+     "status": "ok",
+     "timestamp": 1754098575365,
+     "user": {
+      "displayName": "Jennifer Wei",
+      "userId": "16943650990422967205"
+     },
+     "user_tz": 360
+    },
+    "id": "U0JaCDCvZx3-",
+    "outputId": "d42cf09c-9b25-4bae-f5d3-60d2fea0cba6"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Requirement already satisfied: datasets==3.3.2 in /usr/local/lib/python3.11/dist-packages (3.3.2)\n",
+      "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from datasets==3.3.2) (3.18.0)\n",
+      "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.11/dist-packages (from datasets==3.3.2) (2.2.3)\n",
+      "Requirement already satisfied: pyarrow>=15.0.0 in /usr/local/lib/python3.11/dist-packages (from datasets==3.3.2) (18.1.0)\n",
+      "Requirement already satisfied: dill<0.3.9,>=0.3.0 in /usr/local/lib/python3.11/dist-packages (from datasets==3.3.2) (0.3.8)\n",
+      "Requirement already satisfied: pandas in /usr/local/lib/python3.11/dist-packages (from datasets==3.3.2) (2.2.2)\n",
+      "Requirement already satisfied: requests>=2.32.2 in /usr/local/lib/python3.11/dist-packages (from datasets==3.3.2) (2.32.3)\n",
+      "Requirement already satisfied: tqdm>=4.66.3 in /usr/local/lib/python3.11/dist-packages (from datasets==3.3.2) (4.67.1)\n",
+      "Requirement already satisfied: xxhash in /usr/local/lib/python3.11/dist-packages (from datasets==3.3.2) (3.5.0)\n",
+      "Requirement already satisfied: multiprocess<0.70.17 in /usr/local/lib/python3.11/dist-packages (from datasets==3.3.2) (0.70.16)\n",
+      "Requirement already satisfied: fsspec<=2024.12.0,>=2023.1.0 in /usr/local/lib/python3.11/dist-packages (from fsspec[http]<=2024.12.0,>=2023.1.0->datasets==3.3.2) (2024.12.0)\n",
+      "Requirement already satisfied: aiohttp in /usr/local/lib/python3.11/dist-packages (from datasets==3.3.2) (3.12.14)\n",
+      "Requirement already satisfied: huggingface-hub>=0.24.0 in /usr/local/lib/python3.11/dist-packages (from datasets==3.3.2) (0.34.1)\n",
+      "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from datasets==3.3.2) (25.0)\n",
+      "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.11/dist-packages (from datasets==3.3.2) (6.0.2)\n",
+      "Requirement already satisfied: aiohappyeyeballs>=2.5.0 in /usr/local/lib/python3.11/dist-packages (from aiohttp->datasets==3.3.2) (2.6.1)\n",
+      "Requirement already satisfied: aiosignal>=1.4.0 in /usr/local/lib/python3.11/dist-packages (from aiohttp->datasets==3.3.2) (1.4.0)\n",
+      "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.11/dist-packages (from aiohttp->datasets==3.3.2) (25.3.0)\n",
+      "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.11/dist-packages (from aiohttp->datasets==3.3.2) (1.7.0)\n",
+      "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.11/dist-packages (from aiohttp->datasets==3.3.2) (6.6.3)\n",
+      "Requirement already satisfied: propcache>=0.2.0 in /usr/local/lib/python3.11/dist-packages (from aiohttp->datasets==3.3.2) (0.3.2)\n",
+      "Requirement already satisfied: yarl<2.0,>=1.17.0 in /usr/local/lib/python3.11/dist-packages (from aiohttp->datasets==3.3.2) (1.20.1)\n",
+      "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.11/dist-packages (from huggingface-hub>=0.24.0->datasets==3.3.2) (4.14.1)\n",
+      "Requirement already satisfied: hf-xet<2.0.0,>=1.1.3 in /usr/local/lib/python3.11/dist-packages (from huggingface-hub>=0.24.0->datasets==3.3.2) (1.1.5)\n",
+      "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests>=2.32.2->datasets==3.3.2) (3.4.2)\n",
+      "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests>=2.32.2->datasets==3.3.2) (3.10)\n",
+      "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests>=2.32.2->datasets==3.3.2) (2.5.0)\n",
+      "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests>=2.32.2->datasets==3.3.2) (2025.7.14)\n",
+      "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.11/dist-packages (from pandas->datasets==3.3.2) (2.9.0.post0)\n",
+      "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.11/dist-packages (from pandas->datasets==3.3.2) (2025.2)\n",
+      "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.11/dist-packages (from pandas->datasets==3.3.2) (2025.2)\n",
+      "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.8.2->pandas->datasets==3.3.2) (1.17.0)\n",
+      "Requirement already satisfied: loguru==0.7.3 in /usr/local/lib/python3.11/dist-packages (0.7.3)\n",
+      "Requirement already satisfied: numpy==2.2.3 in /usr/local/lib/python3.11/dist-packages (2.2.3)\n",
+      "Requirement already satisfied: torch==2.6.0 in /usr/local/lib/python3.11/dist-packages (2.6.0+cu124)\n",
+      "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from torch==2.6.0) (3.18.0)\n",
+      "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.11/dist-packages (from torch==2.6.0) (4.14.1)\n",
+      "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch==2.6.0) (3.5)\n",
+      "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from torch==2.6.0) (3.1.6)\n",
+      "Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from torch==2.6.0) (2024.12.0)\n",
+      "Collecting nvidia-cuda-nvrtc-cu12==12.4.127 (from torch==2.6.0)\n",
+      "  Using cached nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
+      "Collecting nvidia-cuda-runtime-cu12==12.4.127 (from torch==2.6.0)\n",
+      "  Using cached nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
+      "Collecting nvidia-cuda-cupti-cu12==12.4.127 (from torch==2.6.0)\n",
+      "  Using cached nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n",
+      "Collecting nvidia-cudnn-cu12==9.1.0.70 (from torch==2.6.0)\n",
+      "  Using cached nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n",
+      "Collecting nvidia-cublas-cu12==12.4.5.8 (from torch==2.6.0)\n",
+      "  Using cached nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
+      "Collecting nvidia-cufft-cu12==11.2.1.3 (from torch==2.6.0)\n",
+      "  Using cached nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
+      "Collecting nvidia-curand-cu12==10.3.5.147 (from torch==2.6.0)\n",
+      "  Using cached nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
+      "Collecting nvidia-cusolver-cu12==11.6.1.9 (from torch==2.6.0)\n",
+      "  Using cached nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n",
+      "Collecting nvidia-cusparse-cu12==12.3.1.170 (from torch==2.6.0)\n",
+      "  Using cached nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n",
+      "Requirement already satisfied: nvidia-cusparselt-cu12==0.6.2 in /usr/local/lib/python3.11/dist-packages (from torch==2.6.0) (0.6.2)\n",
+      "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /usr/local/lib/python3.11/dist-packages (from torch==2.6.0) (2.21.5)\n",
+      "Requirement already satisfied: nvidia-nvtx-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch==2.6.0) (12.4.127)\n",
+      "Collecting nvidia-nvjitlink-cu12==12.4.127 (from torch==2.6.0)\n",
+      "  Using cached nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
+      "Requirement already satisfied: triton==3.2.0 in /usr/local/lib/python3.11/dist-packages (from torch==2.6.0) (3.2.0)\n",
+      "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.11/dist-packages (from torch==2.6.0) (1.13.1)\n",
+      "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy==1.13.1->torch==2.6.0) (1.3.0)\n",
+      "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from jinja2->torch==2.6.0) (3.0.2)\n",
+      "Using cached nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl (363.4 MB)\n",
+      "Using cached nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (13.8 MB)\n",
+      "Using cached nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (24.6 MB)\n",
+      "Using cached nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (883 kB)\n",
+      "Downloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl (664.8 MB)\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m953.8 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25hDownloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl (211.5 MB)\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m5.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25hDownloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl (56.3 MB)\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m13.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25hDownloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl (127.9 MB)\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m7.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25hDownloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl (207.5 MB)\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m5.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25hDownloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (21.1 MB)\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m93.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25hInstalling collected packages: nvidia-nvjitlink-cu12, nvidia-curand-cu12, nvidia-cufft-cu12, nvidia-cuda-runtime-cu12, nvidia-cuda-nvrtc-cu12, nvidia-cuda-cupti-cu12, nvidia-cublas-cu12, nvidia-cusparse-cu12, nvidia-cudnn-cu12, nvidia-cusolver-cu12\n",
+      "  Attempting uninstall: nvidia-nvjitlink-cu12\n",
+      "    Found existing installation: nvidia-nvjitlink-cu12 12.5.82\n",
+      "    Uninstalling nvidia-nvjitlink-cu12-12.5.82:\n",
+      "      Successfully uninstalled nvidia-nvjitlink-cu12-12.5.82\n",
+      "  Attempting uninstall: nvidia-curand-cu12\n",
+      "    Found existing installation: nvidia-curand-cu12 10.3.6.82\n",
+      "    Uninstalling nvidia-curand-cu12-10.3.6.82:\n",
+      "      Successfully uninstalled nvidia-curand-cu12-10.3.6.82\n",
+      "  Attempting uninstall: nvidia-cufft-cu12\n",
+      "    Found existing installation: nvidia-cufft-cu12 11.2.3.61\n",
+      "    Uninstalling nvidia-cufft-cu12-11.2.3.61:\n",
+      "      Successfully uninstalled nvidia-cufft-cu12-11.2.3.61\n",
+      "  Attempting uninstall: nvidia-cuda-runtime-cu12\n",
+      "    Found existing installation: nvidia-cuda-runtime-cu12 12.5.82\n",
+      "    Uninstalling nvidia-cuda-runtime-cu12-12.5.82:\n",
+      "      Successfully uninstalled nvidia-cuda-runtime-cu12-12.5.82\n",
+      "  Attempting uninstall: nvidia-cuda-nvrtc-cu12\n",
+      "    Found existing installation: nvidia-cuda-nvrtc-cu12 12.5.82\n",
+      "    Uninstalling nvidia-cuda-nvrtc-cu12-12.5.82:\n",
+      "      Successfully uninstalled nvidia-cuda-nvrtc-cu12-12.5.82\n",
+      "  Attempting uninstall: nvidia-cuda-cupti-cu12\n",
+      "    Found existing installation: nvidia-cuda-cupti-cu12 12.5.82\n",
+      "    Uninstalling nvidia-cuda-cupti-cu12-12.5.82:\n",
+      "      Successfully uninstalled nvidia-cuda-cupti-cu12-12.5.82\n",
+      "  Attempting uninstall: nvidia-cublas-cu12\n",
+      "    Found existing installation: nvidia-cublas-cu12 12.5.3.2\n",
+      "    Uninstalling nvidia-cublas-cu12-12.5.3.2:\n",
+      "      Successfully uninstalled nvidia-cublas-cu12-12.5.3.2\n",
+      "  Attempting uninstall: nvidia-cusparse-cu12\n",
+      "    Found existing installation: nvidia-cusparse-cu12 12.5.1.3\n",
+      "    Uninstalling nvidia-cusparse-cu12-12.5.1.3:\n",
+      "      Successfully uninstalled nvidia-cusparse-cu12-12.5.1.3\n",
+      "  Attempting uninstall: nvidia-cudnn-cu12\n",
+      "    Found existing installation: nvidia-cudnn-cu12 9.3.0.75\n",
+      "    Uninstalling nvidia-cudnn-cu12-9.3.0.75:\n",
+      "      Successfully uninstalled nvidia-cudnn-cu12-9.3.0.75\n",
+      "  Attempting uninstall: nvidia-cusolver-cu12\n",
+      "    Found existing installation: nvidia-cusolver-cu12 11.6.3.83\n",
+      "    Uninstalling nvidia-cusolver-cu12-11.6.3.83:\n",
+      "      Successfully uninstalled nvidia-cusolver-cu12-11.6.3.83\n",
+      "Successfully installed nvidia-cublas-cu12-12.4.5.8 nvidia-cuda-cupti-cu12-12.4.127 nvidia-cuda-nvrtc-cu12-12.4.127 nvidia-cuda-runtime-cu12-12.4.127 nvidia-cudnn-cu12-9.1.0.70 nvidia-cufft-cu12-11.2.1.3 nvidia-curand-cu12-10.3.5.147 nvidia-cusolver-cu12-11.6.1.9 nvidia-cusparse-cu12-12.3.1.170 nvidia-nvjitlink-cu12-12.4.127\n",
+      "Requirement already satisfied: tqdm==4.67.1 in /usr/local/lib/python3.11/dist-packages (4.67.1)\n",
+      "Collecting transformers==4.49.0\n",
+      "  Downloading transformers-4.49.0-py3-none-any.whl.metadata (44 kB)\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m44.0/44.0 kB\u001b[0m \u001b[31m1.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25hRequirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from transformers==4.49.0) (3.18.0)\n",
+      "Requirement already satisfied: huggingface-hub<1.0,>=0.26.0 in /usr/local/lib/python3.11/dist-packages (from transformers==4.49.0) (0.34.1)\n",
+      "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.11/dist-packages (from transformers==4.49.0) (2.2.3)\n",
+      "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from transformers==4.49.0) (25.0)\n",
+      "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.11/dist-packages (from transformers==4.49.0) (6.0.2)\n",
+      "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.11/dist-packages (from transformers==4.49.0) (2024.11.6)\n",
+      "Requirement already satisfied: requests in /usr/local/lib/python3.11/dist-packages (from transformers==4.49.0) (2.32.3)\n",
+      "Requirement already satisfied: tokenizers<0.22,>=0.21 in /usr/local/lib/python3.11/dist-packages (from transformers==4.49.0) (0.21.2)\n",
+      "Requirement already satisfied: safetensors>=0.4.1 in /usr/local/lib/python3.11/dist-packages (from transformers==4.49.0) (0.5.3)\n",
+      "Requirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.11/dist-packages (from transformers==4.49.0) (4.67.1)\n",
+      "Requirement already satisfied: fsspec>=2023.5.0 in /usr/local/lib/python3.11/dist-packages (from huggingface-hub<1.0,>=0.26.0->transformers==4.49.0) (2024.12.0)\n",
+      "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.11/dist-packages (from huggingface-hub<1.0,>=0.26.0->transformers==4.49.0) (4.14.1)\n",
+      "Requirement already satisfied: hf-xet<2.0.0,>=1.1.3 in /usr/local/lib/python3.11/dist-packages (from huggingface-hub<1.0,>=0.26.0->transformers==4.49.0) (1.1.5)\n",
+      "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests->transformers==4.49.0) (3.4.2)\n",
+      "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests->transformers==4.49.0) (3.10)\n",
+      "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests->transformers==4.49.0) (2.5.0)\n",
+      "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests->transformers==4.49.0) (2025.7.14)\n",
+      "Downloading transformers-4.49.0-py3-none-any.whl (10.0 MB)\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.0/10.0 MB\u001b[0m \u001b[31m52.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25hInstalling collected packages: transformers\n",
+      "  Attempting uninstall: transformers\n",
+      "    Found existing installation: transformers 4.54.0\n",
+      "    Uninstalling transformers-4.54.0:\n",
+      "      Successfully uninstalled transformers-4.54.0\n",
+      "Successfully installed transformers-4.49.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "! pip install datasets==3.3.2\n",
+    "! pip install loguru==0.7.3\n",
+    "! pip install numpy==2.2.3\n",
+    "! pip install torch==2.6.0\n",
+    "! pip install tqdm==4.67.1\n",
+    "! pip install transformers==4.49.0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "collapsed": true,
+    "executionInfo": {
+     "elapsed": 23929,
+     "status": "ok",
+     "timestamp": 1755803894652,
+     "user": {
+      "displayName": "Jennifer Wei",
+      "userId": "16943650990422967205"
+     },
+     "user_tz": 360
+    },
+    "id": "upWDrrdWELJQ",
+    "outputId": "67fdeae9-7a7d-4674-fa9c-afced5ff288a"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collecting loguru\n",
+      "  Downloading loguru-0.7.3-py3-none-any.whl.metadata (22 kB)\n",
+      "Downloading loguru-0.7.3-py3-none-any.whl (61 kB)\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m61.6/61.6 kB\u001b[0m \u001b[31m3.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25hInstalling collected packages: loguru\n",
+      "Successfully installed loguru-0.7.3\n"
+     ]
+    }
+   ],
+   "source": [
+    "    pip install loguru"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jJA-DBFqMdmt"
+   },
+   "source": [
+    "### Muon sudo code\n",
+    "\n",
+    "Input: γ (learning rate), θ₀ (parameters), f(θ) (objective), λ (weight decay),\n",
+    "       μ (momentum), τ (dampening), nesterov, maximize, NS_steps. <br>\n",
+    "\n",
+    "\n",
+    "for t = 1 to ... do\n",
+    "\n",
+    "    if maximize:\n",
+    "        g_t ← -∇_θ f_t(θ_{t-1})\n",
+    "    else:\n",
+    "        g_t ← ∇_θ f_t(θ_{t-1})\n",
+    "    \n",
+    "    if λ ≠ 0:\n",
+    "        θ_t ← θ_{t-1}·(1 - γ·λ)  # Apply weight decay directly to parameters\n",
+    "    \n",
+    "    b_t ← g_t  # Initialize buffer with current gradient\n",
+    "    \n",
+    "    if μ ≠ 0:\n",
+    "        if t > 1:\n",
+    "            b_t ← μ·b_{t-1} + (1-τ)·g_t  # Apply momentum\n",
+    "        \n",
+    "        if nesterov:\n",
+    "            b_t ← g_t + μ·b_t  # or b_t ← (1-μ)·g_t + μ·b_t\n",
+    "    \n",
+    "    # Muon: Apply Newton-Schulz orthogonalization for matrix parameters\n",
+    "    if dim(b_t) ≥ 2:\n",
+    "        # Save original shape\n",
+    "        original_shape ← shape(b_t)\n",
+    "        \n",
+    "        # Reshape to 2D if needed\n",
+    "        if dim(b_t) > 2:\n",
+    "            b_t ← reshape(b_t, [size(b_t, 0), -1])\n",
+    "        \n",
+    "        # Apply Newton-Schulz orthogonalization\n",
+    "        b_t ← NewtonSchulz5(b_t, NS_steps)\n",
+    "        \n",
+    "        # Apply scaling factor for consistent update magnitude\n",
+    "        b_t ← b_t · √max(1, size(b_t, -2)/size(b_t, -1))\n",
+    "        \n",
+    "        # Restore original shape if needed\n",
+    "        if dim(original_shape) > 2:\n",
+    "            b_t ← reshape(b_t, original_shape)\n",
+    "    \n",
+    "    θ_t ← θ_{t-1} - γ·b_t  # Update parameters\n",
+    "\n",
+    "return θ_t"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 4109,
+     "status": "ok",
+     "timestamp": 1756053267821,
+     "user": {
+      "displayName": "Jennifer Wei",
+      "userId": "16943650990422967205"
+     },
+     "user_tz": 360
+    },
+    "id": "GTmXMxquMeNL"
+   },
+   "outputs": [],
+   "source": [
+    "import torch.nn as nn\n",
+    "import torch\n",
+    "import torch.optim as optim\n",
+    "\n",
+    "\n",
+    "def zeropower_via_newtonschulz5(G, steps: int):\n",
+    "    \"\"\"\n",
+    "    Newton-Schulz iteration to compute the zeroth power / orthogonalization of G. We opt to use a\n",
+    "    quintic iteration whose coefficients are selected to maximize the slope at zero. For the purpose\n",
+    "    of minimizing steps, it turns out to be empirically effective to keep increasing the slope at\n",
+    "    zero even beyond the point where the iteration no longer converges all the way to one everywhere\n",
+    "    on the interval. This iteration therefore does not produce UV^T but rather something like US'V^T\n",
+    "    where S' is diagonal with S_{ii}' ~ Uniform(0.5, 1.5), which turns out not to hurt model\n",
+    "    performance at all relative to UV^T, where USV^T = G is the SVD.\n",
+    "    \"\"\"\n",
+    "    assert G.ndim >= 2 # batched Muon implementation by @scottjmaddox, and put into practice in the record by @YouJiacheng\n",
+    "    a, b, c = (3.4445, -4.7750,  2.0315)\n",
+    "    X = G.bfloat16()\n",
+    "    if G.size(-2) > G.size(-1):\n",
+    "        X = X.mT\n",
+    "\n",
+    "    # Ensure spectral norm is at most 1\n",
+    "    X = X / (X.norm(dim=(-2, -1), keepdim=True) + 1e-7)\n",
+    "    # Perform the NS iterations\n",
+    "    for _ in range(steps):\n",
+    "        A = X @ X.mT\n",
+    "        B = b * A + c * A @ A # quintic computation strategy adapted from suggestion by @jxbz, @leloykun, and @YouJiacheng\n",
+    "        X = a * X + B @ X\n",
+    "\n",
+    "    if G.size(-2) > G.size(-1):\n",
+    "        X = X.mT\n",
+    "    return X\n",
+    "\n",
+    "\n",
+    "def muon_update(grad, momentum, beta=0.95, ns_steps=5, nesterov=True):\n",
+    "    momentum.lerp_(grad, 1 - beta)  # momentum = beta * momentum + (1-beta) * grad\n",
+    "    update = momentum*beta + grad*(1-beta) if nesterov else momentum\n",
+    "\n",
+    "    if update.ndim == 4:  # for the case of conv filters\n",
+    "        update = update.view(update.shape[0], -1)  # keep first dim, flatten the rest\n",
+    "\n",
+    "    update = zeropower_via_newtonschulz5(update, steps=ns_steps)\n",
+    "    update *= max(1, grad.size(-2) / grad.size(-1))**0.5\n",
+    "    return update\n",
+    "\n",
+    "\n",
+    "class Muon(optim.Optimizer):\n",
+    "    def __init__(self, params, lr=0.01, momentum=0.95, steps=5,\n",
+    "                 weight_decay=0, nesterov=True, maximize=False):\n",
+    "\n",
+    "        defaults = dict(lr=lr, momentum=momentum, steps=steps,\n",
+    "                        weight_decay=weight_decay, nesterov=nesterov)\n",
+    "        self.maximize = maximize\n",
+    "        super().__init__(params, defaults)\n",
+    "\n",
+    "    @torch.no_grad()\n",
+    "    def step(self, closure=None):\n",
+    "        loss = None\n",
+    "        if closure is not None:\n",
+    "            with torch.enable_grad():\n",
+    "                loss = closure()\n",
+    "\n",
+    "        for group in self.param_groups:\n",
+    "            lr = group['lr']\n",
+    "            momentum = group['momentum']\n",
+    "            steps = group['steps']\n",
+    "            weight_decay = group['weight_decay']\n",
+    "            nesterov = group['nesterov']\n",
+    "\n",
+    "\n",
+    "            for p in group['params']:\n",
+    "                if p.grad is None:\n",
+    "                    continue\n",
+    "\n",
+    "                if self.maximize:\n",
+    "                    grad = -p.grad\n",
+    "                else:\n",
+    "                    grad = p.grad\n",
+    "\n",
+    "                # Get state for this parameter\n",
+    "                state = self.state[p]\n",
+    "                # Initialize momentum buffer if it doesn't exist\n",
+    "                if 'momentum_buffer' not in state:\n",
+    "                    state['momentum_buffer'] = torch.zeros_like(grad)\n",
+    "\n",
+    "                # Apply weight decay directly to parameters (AdamW style)\n",
+    "                if weight_decay != 0:\n",
+    "                    p.mul_(1 - lr * weight_decay)\n",
+    "\n",
+    "                # Apply zeropower_via_newtonschulz5 if parameter is a matrix\n",
+    "                if p.ndim >= 2:\n",
+    "                    org_shape = p.shape\n",
+    "                    orthogonal_buff = muon_update(grad, state[\"momentum_buffer\"],\n",
+    "                                                beta=momentum, ns_steps=steps, nesterov=nesterov)\n",
+    "                    if p.ndim == 4:\n",
+    "                        orthogonal_buff = orthogonal_buff.view(org_shape)\n",
+    "\n",
+    "                    # Apply update to parameters\n",
+    "                    p.add_(orthogonal_buff, alpha=-lr)\n",
+    "                else:\n",
+    "                    # For non-matrix parameters, use standard momentum update\n",
+    "                    buf = state['momentum_buffer']\n",
+    "                    buf.mul_(momentum).add_(grad)\n",
+    "\n",
+    "                    # furhter modify buf if nesterov\n",
+    "                    if nesterov:\n",
+    "                        buf = grad + momentum * buf\n",
+    "\n",
+    "                    # Apply update to parameters\n",
+    "                    p.add_(buf, alpha=-lr)\n",
+    "\n",
+    "        return loss"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 12,
+     "status": "ok",
+     "timestamp": 1756053272119,
+     "user": {
+      "displayName": "Jennifer Wei",
+      "userId": "16943650990422967205"
+     },
+     "user_tz": 360
+    },
+    "id": "Qmuuub1hta2C"
+   },
+   "outputs": [],
+   "source": [
+    "import torch.nn as nn\n",
+    "import torch\n",
+    "import torch.optim as optim\n",
+    "\n",
+    "def optimized_zeropower_via_newtonschulz5(G, steps=5, eps=1e-7):\n",
+    "\n",
+    "    # Instead of Python loop, use JIT compilation\n",
+    "    @torch.jit.script\n",
+    "    def newton_schulz_iteration(X, a: float, b: float, c: float):\n",
+    "        A = torch.matmul(X, X.transpose(-2, -1))\n",
+    "        B = b * A + c * torch.matmul(A, A)\n",
+    "        return a * X + torch.matmul(B, X)\n",
+    "\n",
+    "\n",
+    "    # Move to GPU early and stay there\n",
+    "    device = G.device\n",
+    "    dtype = G.dtype\n",
+    "\n",
+    "    # Convert to contiguous tensors for faster GPU operations\n",
+    "    G = G.contiguous()\n",
+    "\n",
+    "    # Use bfloat16 for faster computation\n",
+    "    X = G.to(torch.bfloat16)\n",
+    "\n",
+    "    # Handle tall matrices\n",
+    "    is_tall = X.size(-2) > X.size(-1)\n",
+    "    if is_tall:\n",
+    "        X = X.transpose(-2, -1)\n",
+    "\n",
+    "    # Normalize\n",
+    "    #X.div_(X.norm(dim=(-2, -1), keepdim=True) + eps)\n",
+    "    # Ensure spectral norm is at most 1 - use fused operations when possible\n",
+    "    norm = torch.linalg.norm(X, dim=(-2, -1), keepdim=True)\n",
+    "    X = torch.div(X, norm + eps)  # Using torch.div is sometimes faster than / operator\n",
+    "\n",
+    "    # Newton-Schulz iterations\n",
+    "    a, b, c = (3.4445, -4.7750, 2.0315)\n",
+    "    \"\"\"\n",
+    "    for _ in range(steps):\n",
+    "        A = X @ X.transpose(-2, -1)\n",
+    "        B = b * A + c * (A @ A)\n",
+    "        X = a * X + B @ X\n",
+    "    \"\"\"\n",
+    "      # Apply iterations\n",
+    "    for _ in range(steps):\n",
+    "        X = newton_schulz_iteration(X, a, b, c)\n",
+    "\n",
+    "\n",
+    "    if is_tall:\n",
+    "        X = X.transpose(-2, -1)\n",
+    "\n",
+    "    # Convert back to original precision\n",
+    "    return X.to(G.dtype)\n",
+    "\n",
+    "\n",
+    "\n",
+    "def optimized_muon_update(grad, momentum, beta=0.95, steps=5, nesterov=True):\n",
+    "    # Update momentum in-place\n",
+    "    momentum.mul_(beta).add_(grad, alpha=1-beta)\n",
+    "\n",
+    "    # Compute update\n",
+    "    if nesterov:\n",
+    "        # Create update without modifying grad\n",
+    "        update = grad * (1-beta) + momentum * beta\n",
+    "    else:\n",
+    "        update = momentum.clone()\n",
+    "\n",
+    "    # Handle reshaping\n",
+    "    original_shape = update.shape\n",
+    "    reshaped = False\n",
+    "    if update.ndim > 2:\n",
+    "        reshaped = True\n",
+    "        update = update.view(update.size(0), -1)\n",
+    "\n",
+    "    # Apply orthogonalization\n",
+    "    update = optimized_zeropower_via_newtonschulz5(update, steps=steps)\n",
+    "\n",
+    "    # Apply scaling\n",
+    "    scale_factor = max(1, update.size(-2) / update.size(-1))**0.5\n",
+    "    update.mul_(scale_factor)\n",
+    "\n",
+    "    # Restore shape if needed\n",
+    "    if reshaped:\n",
+    "        update = update.view(original_shape)\n",
+    "\n",
+    "    return update\n",
+    "\n",
+    "class OptimizedMuon(optim.Optimizer):\n",
+    "    def __init__(self, params, lr=0.01, momentum=0.95, steps=5,\n",
+    "                 weight_decay=0, nesterov=True):\n",
+    "        defaults = dict(lr=lr, momentum=momentum, steps=steps,\n",
+    "                       weight_decay=weight_decay, nesterov=nesterov)\n",
+    "        super().__init__(params, defaults)\n",
+    "\n",
+    "    @torch.no_grad()\n",
+    "    def step(self, closure=None):\n",
+    "        loss = None\n",
+    "        if closure is not None:\n",
+    "            with torch.enable_grad():\n",
+    "                loss = closure()\n",
+    "\n",
+    "        for group in self.param_groups:\n",
+    "            lr = group['lr']\n",
+    "            momentum = group['momentum']\n",
+    "            steps = group['steps']\n",
+    "            weight_decay = group['weight_decay']\n",
+    "            nesterov = group['nesterov']\n",
+    "\n",
+    "            for p in group['params']:\n",
+    "                if p.grad is None:\n",
+    "                    continue\n",
+    "\n",
+    "                grad = p.grad\n",
+    "\n",
+    "                # Get state for this parameter\n",
+    "                state = self.state[p]\n",
+    "                # Initialize momentum buffer if it doesn't exist\n",
+    "                if 'momentum_buffer' not in state:\n",
+    "                    state['momentum_buffer'] = torch.zeros_like(grad)\n",
+    "\n",
+    "                # Apply weight decay\n",
+    "                if weight_decay != 0:\n",
+    "                    p.mul_(1 - lr * weight_decay)\n",
+    "\n",
+    "                # Apply Muon update for matrix parameters\n",
+    "                if p.ndim >= 2:\n",
+    "                    update = optimized_muon_update(grad, state['momentum_buffer'],\n",
+    "                                                beta=momentum, steps=steps,\n",
+    "                                                nesterov=nesterov)\n",
+    "                    p.add_(update, alpha=-lr)\n",
+    "                else:\n",
+    "                    # For non-matrix parameters, use standard momentum update\n",
+    "                    buf = state['momentum_buffer']\n",
+    "                    buf.mul_(momentum).add_(grad)\n",
+    "\n",
+    "                    if nesterov:\n",
+    "                        update = grad + momentum * buf\n",
+    "                    else:\n",
+    "                        update = buf\n",
+    "\n",
+    "                    p.add_(update, alpha=-lr)\n",
+    "\n",
+    "        return loss"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 935
+    },
+    "executionInfo": {
+     "elapsed": 73941,
+     "status": "ok",
+     "timestamp": 1756054042596,
+     "user": {
+      "displayName": "Jennifer Wei",
+      "userId": "16943650990422967205"
+     },
+     "user_tz": 360
+    },
+    "id": "FEl38xiZZ5Wo",
+    "outputId": "8f280ea0-908f-44e1-e562-35f55c5cdbe6"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "--- Training with Muon ---\n",
+      "Muon | Epoch 1, avg loss: 0.2778, time: 9.70 seconds\n",
+      "Muon | Epoch 2, avg loss: 0.0680, time: 9.65 seconds\n",
+      "Muon | Epoch 3, avg loss: 0.0475, time: 9.51 seconds\n",
+      "Muon | Total training time: 28.86 seconds\n",
+      "\n",
+      "--- Training with SGD ---\n",
+      "SGD | Epoch 1, avg loss: 1.7083, time: 7.29 seconds\n",
+      "SGD | Epoch 2, avg loss: 0.5566, time: 7.24 seconds\n",
+      "SGD | Epoch 3, avg loss: 0.3931, time: 7.30 seconds\n",
+      "SGD | Total training time: 21.84 seconds\n",
+      "\n",
+      "--- Training with AdamW ---\n",
+      "AdamW | Epoch 1, avg loss: 0.2847, time: 7.63 seconds\n",
+      "AdamW | Epoch 2, avg loss: 0.1075, time: 7.50 seconds\n",
+      "AdamW | Epoch 3, avg loss: 0.0717, time: 7.58 seconds\n",
+      "AdamW | Total training time: 22.71 seconds\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "--- Performance Summary ---\n",
+      "Optimizer | Final Loss | Total Time (s) | Relative Speed\n",
+      "Muon         | 0.0475     | 28.86          | 1.32x\n",
+      "SGD          | 0.3931     | 21.84          | 1.00x\n",
+      "AdamW        | 0.0717     | 22.71          | 1.04x\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "from torchvision import datasets, transforms\n",
+    "from torch.utils.data import DataLoader\n",
+    "import matplotlib.pyplot as plt\n",
+    "import time  # Import time module for timing\n",
+    "\n",
+    "# --- your optimizer import here ---\n",
+    "# from muon import Muon\n",
+    "\n",
+    "# Simple MLP for MNIST\n",
+    "class MLP(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super().__init__()\n",
+    "        self.fc1 = nn.Linear(28*28, 256)\n",
+    "        self.fc2 = nn.Linear(256, 128)\n",
+    "        self.fc3 = nn.Linear(128, 10)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = x.view(x.size(0), -1)\n",
+    "        x = F.relu(self.fc1(x))\n",
+    "        x = F.relu(self.fc2(x))\n",
+    "        return self.fc3(x)\n",
+    "\n",
+    "# Dataset & loader\n",
+    "transform = transforms.Compose([transforms.ToTensor()])\n",
+    "train_ds = datasets.MNIST(root=\"./data\", train=True, download=True, transform=transform)\n",
+    "train_loader = DataLoader(train_ds, batch_size=64, shuffle=True)\n",
+    "\n",
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "\n",
+    "# --- Define the optimizers you want to compare ---\n",
+    "optimizers_dict = {\n",
+    "    \"Muon\": lambda params: Muon(params, lr=1e-2),\n",
+    "    #\"OptimizedMuon\": lambda params: OptimizedMuon(params, lr=1e-2),\n",
+    "    \"SGD\": lambda params: torch.optim.SGD(params, lr=1e-2),\n",
+    "    \"AdamW\": lambda params: torch.optim.AdamW(params, lr=0.001, weight_decay=0.01),\n",
+    "}\n",
+    "\n",
+    "results = {}  # store loss curves\n",
+    "time_results = {}  # store timing information\n",
+    "\n",
+    "for opt_name, opt_fn in optimizers_dict.items():\n",
+    "    print(f\"\\n--- Training with {opt_name} ---\")\n",
+    "    model = MLP().to(device)  # re-init model each time\n",
+    "    optimizer = opt_fn(model.parameters())\n",
+    "\n",
+    "    losses = []\n",
+    "    epoch_times = []\n",
+    "\n",
+    "    for epoch in range(1, 4):  # just 3 epochs to test\n",
+    "        epoch_start_time = time.time()\n",
+    "        total_loss = 0\n",
+    "\n",
+    "        for x, y in train_loader:\n",
+    "            x, y = x.to(device), y.to(device)\n",
+    "            optimizer.zero_grad()\n",
+    "            out = model(x)\n",
+    "            loss = criterion(out, y)\n",
+    "            loss.backward()\n",
+    "            optimizer.step()\n",
+    "            total_loss += loss.item()\n",
+    "\n",
+    "        epoch_end_time = time.time()\n",
+    "        epoch_duration = epoch_end_time - epoch_start_time\n",
+    "        epoch_times.append(epoch_duration)\n",
+    "\n",
+    "        avg_loss = total_loss / len(train_loader)\n",
+    "        losses.append(avg_loss)\n",
+    "        print(f\"{opt_name} | Epoch {epoch}, avg loss: {avg_loss:.4f}, time: {epoch_duration:.2f} seconds\")\n",
+    "\n",
+    "    results[opt_name] = losses\n",
+    "    time_results[opt_name] = epoch_times\n",
+    "\n",
+    "    # Calculate and print total training time\n",
+    "    total_time = sum(epoch_times)\n",
+    "    print(f\"{opt_name} | Total training time: {total_time:.2f} seconds\")\n",
+    "\n",
+    "# --- Plot results ---\n",
+    "# 1. Loss vs Epoch\n",
+    "plt.figure(figsize=(12, 5))\n",
+    "plt.subplot(1, 2, 1)\n",
+    "for opt_name, losses in results.items():\n",
+    "    plt.plot(range(1, len(losses)+1), losses, label=opt_name, marker=\"o\")\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "plt.ylabel(\"Average Loss\")\n",
+    "plt.title(\"Loss vs Epoch for Different Optimizers\")\n",
+    "plt.legend()\n",
+    "plt.grid(True)\n",
+    "\n",
+    "# 2. Time vs Optimizer\n",
+    "plt.subplot(1, 2, 2)\n",
+    "opt_names = list(time_results.keys())\n",
+    "total_times = [sum(times) for times in time_results.values()]\n",
+    "plt.bar(opt_names, total_times)\n",
+    "plt.ylabel(\"Total Training Time (seconds)\")\n",
+    "plt.title(\"Training Time Comparison\")\n",
+    "plt.xticks(rotation=45)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "# Also print a summary table\n",
+    "print(\"\\n--- Performance Summary ---\")\n",
+    "print(\"Optimizer | Final Loss | Total Time (s) | Relative Speed\")\n",
+    "fastest_time = min(total_times)\n",
+    "for i, opt_name in enumerate(opt_names):\n",
+    "    final_loss = results[opt_name][-1]\n",
+    "    total_time = total_times[i]\n",
+    "    relative_speed = total_time / fastest_time\n",
+    "    print(f\"{opt_name:12} | {final_loss:.4f}     | {total_time:.2f}          | {relative_speed:.2f}x\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000
+    },
+    "executionInfo": {
+     "elapsed": 171351,
+     "status": "ok",
+     "timestamp": 1756057605331,
+     "user": {
+      "displayName": "Jennifer Wei",
+      "userId": "16943650990422967205"
+     },
+     "user_tz": 360
+    },
+    "id": "LBFdN3eAPlSM",
+    "outputId": "3e7ad2e1-6f74-49f2-d94c-06ab19119be3"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "--- Training with Muon ---\n",
+      "Epoch [1/5], Step [100/391], Loss: 1.5581\n",
+      "Epoch [1/5], Step [200/391], Loss: 1.3923\n",
+      "Epoch [1/5], Step [300/391], Loss: 1.0872\n",
+      "Muon | Epoch 1, avg loss: 1.4218, test acc: 68.08%, time: 10.11 seconds\n",
+      "Epoch [2/5], Step [100/391], Loss: 0.9976\n",
+      "Epoch [2/5], Step [200/391], Loss: 0.8543\n",
+      "Epoch [2/5], Step [300/391], Loss: 0.8937\n",
+      "Muon | Epoch 2, avg loss: 0.9570, test acc: 74.27%, time: 9.95 seconds\n",
+      "Epoch [3/5], Step [100/391], Loss: 0.8981\n",
+      "Epoch [3/5], Step [200/391], Loss: 0.8618\n",
+      "Epoch [3/5], Step [300/391], Loss: 0.7957\n",
+      "Muon | Epoch 3, avg loss: 0.8087, test acc: 76.90%, time: 9.87 seconds\n",
+      "Epoch [4/5], Step [100/391], Loss: 0.6446\n",
+      "Epoch [4/5], Step [200/391], Loss: 0.6023\n",
+      "Epoch [4/5], Step [300/391], Loss: 0.7697\n",
+      "Muon | Epoch 4, avg loss: 0.6992, test acc: 79.84%, time: 9.80 seconds\n",
+      "Epoch [5/5], Step [100/391], Loss: 0.6941\n",
+      "Epoch [5/5], Step [200/391], Loss: 0.7476\n",
+      "Epoch [5/5], Step [300/391], Loss: 0.6611\n",
+      "Muon | Epoch 5, avg loss: 0.6279, test acc: 80.79%, time: 9.74 seconds\n",
+      "Muon | Total training time: 49.47 seconds\n",
+      "\n",
+      "--- Training with SGD ---\n",
+      "Epoch [1/5], Step [100/391], Loss: 2.0299\n",
+      "Epoch [1/5], Step [200/391], Loss: 1.8432\n",
+      "Epoch [1/5], Step [300/391], Loss: 1.6052\n",
+      "SGD | Epoch 1, avg loss: 1.8641, test acc: 45.70%, time: 9.69 seconds\n",
+      "Epoch [2/5], Step [100/391], Loss: 1.5299\n",
+      "Epoch [2/5], Step [200/391], Loss: 1.4999\n",
+      "Epoch [2/5], Step [300/391], Loss: 1.4302\n",
+      "SGD | Epoch 2, avg loss: 1.4866, test acc: 53.82%, time: 9.85 seconds\n",
+      "Epoch [3/5], Step [100/391], Loss: 1.4620\n",
+      "Epoch [3/5], Step [200/391], Loss: 1.4355\n",
+      "Epoch [3/5], Step [300/391], Loss: 1.2728\n",
+      "SGD | Epoch 3, avg loss: 1.3144, test acc: 58.98%, time: 10.06 seconds\n",
+      "Epoch [4/5], Step [100/391], Loss: 1.1842\n",
+      "Epoch [4/5], Step [200/391], Loss: 1.2269\n",
+      "Epoch [4/5], Step [300/391], Loss: 1.2441\n",
+      "SGD | Epoch 4, avg loss: 1.1791, test acc: 61.74%, time: 9.75 seconds\n",
+      "Epoch [5/5], Step [100/391], Loss: 1.1005\n",
+      "Epoch [5/5], Step [200/391], Loss: 1.2733\n",
+      "Epoch [5/5], Step [300/391], Loss: 1.2331\n",
+      "SGD | Epoch 5, avg loss: 1.1023, test acc: 64.40%, time: 9.96 seconds\n",
+      "SGD | Total training time: 49.30 seconds\n",
+      "\n",
+      "--- Training with AdamW ---\n",
+      "Epoch [1/5], Step [100/391], Loss: 1.7317\n",
+      "Epoch [1/5], Step [200/391], Loss: 1.4927\n",
+      "Epoch [1/5], Step [300/391], Loss: 1.6410\n",
+      "AdamW | Epoch 1, avg loss: 1.6096, test acc: 55.98%, time: 10.36 seconds\n",
+      "Epoch [2/5], Step [100/391], Loss: 1.3103\n",
+      "Epoch [2/5], Step [200/391], Loss: 1.1878\n",
+      "Epoch [2/5], Step [300/391], Loss: 1.2176\n",
+      "AdamW | Epoch 2, avg loss: 1.2443, test acc: 61.79%, time: 10.00 seconds\n",
+      "Epoch [3/5], Step [100/391], Loss: 1.0259\n",
+      "Epoch [3/5], Step [200/391], Loss: 1.1576\n",
+      "Epoch [3/5], Step [300/391], Loss: 0.9326\n",
+      "AdamW | Epoch 3, avg loss: 1.0696, test acc: 66.48%, time: 10.05 seconds\n",
+      "Epoch [4/5], Step [100/391], Loss: 1.1166\n",
+      "Epoch [4/5], Step [200/391], Loss: 0.9338\n",
+      "Epoch [4/5], Step [300/391], Loss: 0.9345\n",
+      "AdamW | Epoch 4, avg loss: 0.9635, test acc: 69.78%, time: 9.92 seconds\n",
+      "Epoch [5/5], Step [100/391], Loss: 0.9656\n",
+      "Epoch [5/5], Step [200/391], Loss: 0.9924\n",
+      "Epoch [5/5], Step [300/391], Loss: 0.9017\n",
+      "AdamW | Epoch 5, avg loss: 0.8955, test acc: 71.66%, time: 9.93 seconds\n",
+      "AdamW | Total training time: 50.25 seconds\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "--- Performance Summary ---\n",
+      "Optimizer | Final Loss | Final Acc (%) | Total Time (s) | Relative Speed\n",
+      "Muon         | 0.6279     | 80.79        | 49.47          | 1.00x\n",
+      "SGD          | 1.1023     | 64.40        | 49.30          | 1.00x\n",
+      "AdamW        | 0.8955     | 71.66        | 50.25          | 1.02x\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "from torchvision import datasets, transforms\n",
+    "from torch.utils.data import DataLoader\n",
+    "import matplotlib.pyplot as plt\n",
+    "import time\n",
+    "\n",
+    "# Import your optimizers\n",
+    "# from muon import Muon, OptimizedMuon\n",
+    "\n",
+    "# Define a more substantial CNN for CIFAR-10\n",
+    "class CIFAR10CNN(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super().__init__()\n",
+    "        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)\n",
+    "        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
+    "        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)\n",
+    "        self.pool = nn.MaxPool2d(2, 2)\n",
+    "        self.fc1 = nn.Linear(128 * 4 * 4, 512)\n",
+    "        self.fc2 = nn.Linear(512, 10)\n",
+    "        self.dropout = nn.Dropout(0.5)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.pool(F.relu(self.conv1(x)))\n",
+    "        x = self.pool(F.relu(self.conv2(x)))\n",
+    "        x = self.pool(F.relu(self.conv3(x)))\n",
+    "        x = x.view(-1, 128 * 4 * 4)\n",
+    "        x = self.dropout(F.relu(self.fc1(x)))\n",
+    "        x = self.fc2(x)\n",
+    "        return x\n",
+    "\n",
+    "# Dataset & loader with augmentation\n",
+    "transform_train = transforms.Compose([\n",
+    "    transforms.RandomCrop(32, padding=4),\n",
+    "    transforms.RandomHorizontalFlip(),\n",
+    "    transforms.ToTensor(),\n",
+    "    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n",
+    "])\n",
+    "\n",
+    "transform_test = transforms.Compose([\n",
+    "    transforms.ToTensor(),\n",
+    "    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n",
+    "])\n",
+    "\n",
+    "# Increase batch size for more realistic training\n",
+    "batch_size = 128\n",
+    "\n",
+    "train_ds = datasets.CIFAR10(root=\"./data\", train=True, download=True, transform=transform_train)\n",
+    "train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True, num_workers=2)\n",
+    "\n",
+    "test_ds = datasets.CIFAR10(root=\"./data\", train=False, download=True, transform=transform_test)\n",
+    "test_loader = DataLoader(test_ds, batch_size=batch_size, shuffle=False, num_workers=2)\n",
+    "\n",
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "\n",
+    "# Function to evaluate model\n",
+    "def evaluate(model, dataloader):\n",
+    "    model.eval()\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    with torch.no_grad():\n",
+    "        for images, labels in dataloader:\n",
+    "            images, labels = images.to(device), labels.to(device)\n",
+    "            outputs = model(images)\n",
+    "            _, predicted = torch.max(outputs.data, 1)\n",
+    "            total += labels.size(0)\n",
+    "            correct += (predicted == labels).sum().item()\n",
+    "    return 100 * correct / total\n",
+    "\n",
+    "# --- Define the optimizers you want to compare ---\n",
+    "optimizers_dict = {\n",
+    "    \"Muon\": lambda params: Muon(params, lr=1e-2),\n",
+    "    # \"OptimizedMuon\": lambda params: OptimizedMuon(params, lr=1e-3),\n",
+    "    \"SGD\": lambda params: torch.optim.SGD(params, lr=1e-2, momentum=0.9, weight_decay=5e-4),\n",
+    "    \"AdamW\": lambda params: torch.optim.AdamW(params, lr=1e-3, weight_decay=1e-4),\n",
+    "}\n",
+    "\n",
+    "results = {}  # store loss curves\n",
+    "accuracy_results = {}  # store accuracy curves\n",
+    "time_results = {}  # store timing information\n",
+    "\n",
+    "# --- Train for each optimizer ---\n",
+    "for opt_name, opt_fn in optimizers_dict.items():\n",
+    "    print(f\"\\n--- Training with {opt_name} ---\")\n",
+    "    model = CIFAR10CNN().to(device)  # re-init model each time\n",
+    "    optimizer = opt_fn(model.parameters())\n",
+    "\n",
+    "    # Learning rate scheduler\n",
+    "    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=5)\n",
+    "\n",
+    "    losses = []\n",
+    "    accuracies = []\n",
+    "    epoch_times = []\n",
+    "\n",
+    "    for epoch in range(1, 6):  # Train for 5 epochs\n",
+    "        model.train()\n",
+    "        epoch_start_time = time.time()\n",
+    "        total_loss = 0\n",
+    "\n",
+    "        for i, (x, y) in enumerate(train_loader):\n",
+    "            x, y = x.to(device), y.to(device)\n",
+    "            optimizer.zero_grad()\n",
+    "            out = model(x)\n",
+    "            loss = criterion(out, y)\n",
+    "            loss.backward()\n",
+    "            optimizer.step()\n",
+    "            total_loss += loss.item()\n",
+    "\n",
+    "            # Print progress\n",
+    "            if (i+1) % 100 == 0:\n",
+    "                print(f'Epoch [{epoch}/5], Step [{i+1}/{len(train_loader)}], Loss: {loss.item():.4f}')\n",
+    "\n",
+    "        epoch_end_time = time.time()\n",
+    "        epoch_duration = epoch_end_time - epoch_start_time\n",
+    "        epoch_times.append(epoch_duration)\n",
+    "\n",
+    "        # Evaluate\n",
+    "        test_acc = evaluate(model, test_loader)\n",
+    "\n",
+    "        avg_loss = total_loss / len(train_loader)\n",
+    "        losses.append(avg_loss)\n",
+    "        accuracies.append(test_acc)\n",
+    "\n",
+    "        print(f\"{opt_name} | Epoch {epoch}, avg loss: {avg_loss:.4f}, test acc: {test_acc:.2f}%, time: {epoch_duration:.2f} seconds\")\n",
+    "\n",
+    "        # Update learning rate\n",
+    "        scheduler.step()\n",
+    "\n",
+    "    results[opt_name] = losses\n",
+    "    accuracy_results[opt_name] = accuracies\n",
+    "    time_results[opt_name] = epoch_times\n",
+    "\n",
+    "    # Calculate and print total training time\n",
+    "    total_time = sum(epoch_times)\n",
+    "    print(f\"{opt_name} | Total training time: {total_time:.2f} seconds\")\n",
+    "\n",
+    "# --- Plot results ---\n",
+    "# 1. Loss vs Epoch\n",
+    "plt.figure(figsize=(15, 5))\n",
+    "plt.subplot(1, 3, 1)\n",
+    "for opt_name, losses in results.items():\n",
+    "    plt.plot(range(1, len(losses)+1), losses, label=opt_name, marker=\"o\")\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "plt.ylabel(\"Average Loss\")\n",
+    "plt.title(\"Loss vs Epoch for Different Optimizers\")\n",
+    "plt.legend()\n",
+    "plt.grid(True)\n",
+    "\n",
+    "# 2. Accuracy vs Epoch\n",
+    "plt.subplot(1, 3, 2)\n",
+    "for opt_name, accuracies in accuracy_results.items():\n",
+    "    plt.plot(range(1, len(accuracies)+1), accuracies, label=opt_name, marker=\"o\")\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "plt.ylabel(\"Test Accuracy (%)\")\n",
+    "plt.title(\"Accuracy vs Epoch for Different Optimizers\")\n",
+    "plt.legend()\n",
+    "plt.grid(True)\n",
+    "\n",
+    "# 3. Time vs Optimizer\n",
+    "plt.subplot(1, 3, 3)\n",
+    "opt_names = list(time_results.keys())\n",
+    "total_times = [sum(times) for times in time_results.values()]\n",
+    "plt.bar(opt_names, total_times)\n",
+    "plt.ylabel(\"Total Training Time (seconds)\")\n",
+    "plt.title(\"Training Time Comparison\")\n",
+    "plt.xticks(rotation=45)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "# Also print a summary table\n",
+    "print(\"\\n--- Performance Summary ---\")\n",
+    "print(\"Optimizer | Final Loss | Final Acc (%) | Total Time (s) | Relative Speed\")\n",
+    "fastest_time = min(total_times)\n",
+    "for i, opt_name in enumerate(opt_names):\n",
+    "    final_loss = results[opt_name][-1]\n",
+    "    final_acc = accuracy_results[opt_name][-1]\n",
+    "    total_time = total_times[i]\n",
+    "    relative_speed = total_time / fastest_time\n",
+    "    print(f\"{opt_name:12} | {final_loss:.4f}     | {final_acc:.2f}        | {total_time:.2f}          | {relative_speed:.2f}x\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "hoQLfjvTtanY"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "9kQYf2SdYK2s"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "JCuSAhm2MwBm"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "nu_zcQjxMvzY"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "8VQIvQXsZ5fz"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "uz222PNGZ5GD"
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "authorship_tag": "ABX9TyNpihDjeWScc6X13vpBHvcq",
+   "gpuType": "A100",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}