Upload lokr_to_lora_klein9b.ipynb

lokr_to_lora_klein9b.ipynb

@@ -0,0 +1,637 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "source": [
+        "#@markdown # CELL 1 — Setup environment + login\n",
+        "\n",
+        "from google.colab import drive, userdata\n",
+        "from huggingface_hub import login\n",
+        "import torch, os, gc\n",
+        "\n",
+        "drive.mount(\"/content/drive\")\n",
+        "\n",
+        "hf_token = userdata.get(\"HF_TOKEN\")\n",
+        "if hf_token:\n",
+        "    login(token=hf_token)\n",
+        "else:\n",
+        "    raise ValueError(\"HF_TOKEN not found in Google Colab secrets\")\n",
+        "\n",
+        "print(\"✅ Logged into Hugging Face\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "FyTqzDtuIXeN",
+        "outputId": "fa2fc6f3-0ee9-44eb-8a45-12b292775737"
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n",
+            "✅ Logged into Hugging Face\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 873
+        },
+        "id": "ALQyKP5OHZ_N",
+        "outputId": "1efb903b-4aa1-4f4c-80af-6c040614a9a6"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "✅ Using device: cuda\n",
+            "\n",
+            "Loading LoKr: /content/klein9b_snofs_v1.safetensors\n",
+            "Total keys in original LoKr: 336\n",
+            "\n",
+            "Detected 112 LoKr modules.\n",
+            "\n",
+            "🔄 Converting LoKr → LoRA layers...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\rConverting:   0%|          | 0/112 [00:00<?, ?it/s]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "  diffusion_model.double_blocks.0.img_attn.proj                | w1=torch.Size([4, 4]) | w2=torch.Size([1024, 1024]) | α=9999220736.000\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\rConverting:   1%|          | 1/112 [00:11<21:58, 11.87s/it]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "    → lora_A: torch.Size([1, 4096]) | lora_B: torch.Size([4096, 1])\n",
+            "  diffusion_model.double_blocks.0.img_attn.qkv                 | w1=torch.Size([4, 4]) | w2=torch.Size([3072, 1024]) | α=9999220736.000\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\rConverting:   2%|▏         | 2/112 [00:24<22:38, 12.35s/it]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "    → lora_A: torch.Size([1, 4096]) | lora_B: torch.Size([12288, 1])\n",
+            "  diffusion_model.double_blocks.0.img_mlp.0                    | w1=torch.Size([4, 4]) | w2=torch.Size([6144, 1024]) | α=9999220736.000\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\rConverting:   3%|▎         | 3/112 [00:40<25:38, 14.11s/it]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "    → lora_A: torch.Size([1, 4096]) | lora_B: torch.Size([24576, 1])\n",
+            "  diffusion_model.double_blocks.0.img_mlp.2                    | w1=torch.Size([4, 4]) | w2=torch.Size([1024, 3072]) | α=9999220736.000\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\rConverting:   4%|▎         | 4/112 [00:51<23:14, 12.91s/it]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "    → lora_A: torch.Size([1, 12288]) | lora_B: torch.Size([4096, 1])\n",
+            "  diffusion_model.double_blocks.0.txt_attn.proj                | w1=torch.Size([4, 4]) | w2=torch.Size([1024, 1024]) | α=9999220736.000\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\rConverting:   4%|▍         | 5/112 [01:03<22:04, 12.38s/it]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "    → lora_A: torch.Size([1, 4096]) | lora_B: torch.Size([4096, 1])\n",
+            "  diffusion_model.double_blocks.0.txt_attn.qkv                 | w1=torch.Size([4, 4]) | w2=torch.Size([3072, 1024]) | α=9999220736.000\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\rConverting:   5%|▌         | 6/112 [01:15<21:31, 12.18s/it]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "    → lora_A: torch.Size([1, 4096]) | lora_B: torch.Size([12288, 1])\n",
+            "  diffusion_model.double_blocks.0.txt_mlp.0                    | w1=torch.Size([4, 4]) | w2=torch.Size([6144, 1024]) | α=9999220736.000\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\rConverting:   6%|▋         | 7/112 [01:30<22:59, 13.13s/it]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "    → lora_A: torch.Size([1, 4096]) | lora_B: torch.Size([24576, 1])\n",
+            "  diffusion_model.double_blocks.0.txt_mlp.2                    | w1=torch.Size([4, 4]) | w2=torch.Size([1024, 3072]) | α=9999220736.000\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\rConverting:   7%|▋         | 8/112 [01:41<21:54, 12.63s/it]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "    → lora_A: torch.Size([1, 12288]) | lora_B: torch.Size([4096, 1])\n",
+            "  diffusion_model.double_blocks.1.img_attn.proj                | w1=torch.Size([4, 4]) | w2=torch.Size([1024, 1024]) | α=9999220736.000\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\rConverting:   8%|▊         | 9/112 [01:53<21:18, 12.42s/it]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "    → lora_A: torch.Size([1, 4096]) | lora_B: torch.Size([4096, 1])\n",
+            "  diffusion_model.double_blocks.1.img_attn.qkv                 | w1=torch.Size([4, 4]) | w2=torch.Size([3072, 1024]) | α=9999220736.000\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\rConverting:   9%|▉         | 10/112 [02:05<20:58, 12.33s/it]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "    → lora_A: torch.Size([1, 4096]) | lora_B: torch.Size([12288, 1])\n",
+            "  diffusion_model.double_blocks.1.img_mlp.0                    | w1=torch.Size([4, 4]) | w2=torch.Size([6144, 1024]) | α=9999220736.000\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\rConverting:   9%|▉         | 10/112 [02:21<24:05, 14.17s/it]\n"
+          ]
+        },
+        {
+          "output_type": "error",
+          "ename": "KeyboardInterrupt",
+          "evalue": "",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+            "\u001b[0;32m/tmp/ipykernel_22195/4205228776.py\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[1;32m    123\u001b[0m \u001b[0;31m# ====================== RUN THE SCRIPT ======================\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    124\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m__name__\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"__main__\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 125\u001b[0;31m     output_dir, full_lora_path = convert_lokr_to_lora(\n\u001b[0m\u001b[1;32m    126\u001b[0m         \u001b[0mrepo_id\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"codeShare/flux-klein-9B-loras\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    127\u001b[0m         \u001b[0mlokr_filename\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"klein9b_snofs_v1.safetensors\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/tmp/ipykernel_22195/4205228776.py\u001b[0m in \u001b[0;36mconvert_lokr_to_lora\u001b[0;34m(repo_id, lokr_filename, output_dir, final_lora_name, target_rank, hf_token)\u001b[0m\n\u001b[1;32m     65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m         \u001b[0;31m# SVD Decomposition\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m         \u001b[0mU\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mS\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mVh\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msvd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdelta\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     68\u001b[0m         \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtarget_rank\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mS\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+          ]
+        }
+      ],
+      "source": [
+        "import torch\n",
+        "import os\n",
+        "from safetensors.torch import load_file, save_file\n",
+        "from huggingface_hub import hf_hub_download\n",
+        "from collections import defaultdict\n",
+        "from tqdm import tqdm\n",
+        "import math\n",
+        "import glob\n",
+        "\n",
+        "\n",
+        "def convert_lokr_to_lora(\n",
+        "    repo_id: str = \"codeShare/flux-klein-9B-loras\",\n",
+        "    lokr_filename: str = \"klein9b_snofs_v1.safetensors\",\n",
+        "    output_dir: str = \"/content/lora_individual_layers\",\n",
+        "    final_lora_name: str = \"klein9b_snofs_v1_full_lora.safetensors\",\n",
+        "    target_rank: int = 128,\n",
+        "    hf_token: str = None\n",
+        "):\n",
+        "    device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+        "    print(f\"✅ Using device: {device}\\n\")\n",
+        "\n",
+        "    # ====================== 1. DOWNLOAD & LOAD LoKr ======================\n",
+        "    lokr_path = hf_hub_download(repo_id=repo_id, filename=lokr_filename, token=hf_token, local_dir=\"/content\")\n",
+        "    print(f\"Loading LoKr: {lokr_path}\")\n",
+        "    state_dict = load_file(lokr_path, device=\"cpu\")\n",
+        "\n",
+        "    print(f\"Total keys in original LoKr: {len(state_dict)}\\n\")\n",
+        "\n",
+        "    modules = defaultdict(dict)\n",
+        "\n",
+        "    # Parse LoKr modules\n",
+        "    for key, tensor in state_dict.items():\n",
+        "        if key.endswith('.alpha'):\n",
+        "            base = key[:-6]\n",
+        "            modules[base]['alpha'] = float(tensor.item())\n",
+        "            continue\n",
+        "        if '.lokr_' in key:\n",
+        "            base = key.split('.lokr_')[0]\n",
+        "            part = key.split('.')[-1]\n",
+        "            modules[base][part] = tensor\n",
+        "\n",
+        "    print(f\"Detected {len(modules)} LoKr modules.\\n\")\n",
+        "\n",
+        "    os.makedirs(output_dir, exist_ok=True)\n",
+        "\n",
+        "    converted = 0\n",
+        "    merged_state_dict = {}\n",
+        "\n",
+        "    print(\"🔄 Converting LoKr → LoRA layers...\")\n",
+        "\n",
+        "    for base_key, weights in tqdm(modules.items(), desc=\"Converting\"):\n",
+        "        alpha = weights.get('alpha', 1.0)\n",
+        "\n",
+        "        if 'lokr_w1' not in weights or 'lokr_w2' not in weights:\n",
+        "            print(f\"⚠️  Skipping {base_key} (missing w1/w2)\")\n",
+        "            continue\n",
+        "\n",
+        "        w1 = weights['lokr_w1'].to(device, dtype=torch.float32)\n",
+        "        w2 = weights['lokr_w2'].to(device, dtype=torch.float32)\n",
+        "\n",
+        "        print(f\"  {base_key:60} | w1={w1.shape} | w2={w2.shape} | α={alpha:.3f}\")\n",
+        "\n",
+        "        # Kronecker product\n",
+        "        delta = torch.kron(w1, w2)\n",
+        "\n",
+        "        # SVD Decomposition\n",
+        "        U, S, Vh = torch.linalg.svd(delta)\n",
+        "        r = min(target_rank, S.shape[0])\n",
+        "\n",
+        "        sqrt_s = S[:r].sqrt().unsqueeze(1)\n",
+        "\n",
+        "        # Correct LoRA matrices (Standard convention)\n",
+        "        lora_A = (sqrt_s.T @ Vh[:r, :])          # (rank, in_features)\n",
+        "        lora_B = (U[:, :r] @ sqrt_s)             # (out_features, rank)\n",
+        "\n",
+        "        scale = alpha / math.sqrt(r)\n",
+        "\n",
+        "        lora_A = (lora_A * scale).to(torch.bfloat16).cpu()\n",
+        "        lora_B = (lora_B * scale).to(torch.bfloat16).cpu()\n",
+        "\n",
+        "        print(f\"    → lora_A: {lora_A.shape} | lora_B: {lora_B.shape}\")\n",
+        "\n",
+        "        # Save individual layer\n",
+        "        layer_dict = {\n",
+        "            f\"{base_key}.lora_A.weight\": lora_A,\n",
+        "            f\"{base_key}.lora_B.weight\": lora_B,\n",
+        "        }\n",
+        "\n",
+        "        safe_name = base_key.replace(\".\", \"_\").replace(\"/\", \"_\")\n",
+        "        layer_path = os.path.join(output_dir, f\"{safe_name}.safetensors\")\n",
+        "        save_file(layer_dict, layer_path)\n",
+        "\n",
+        "        # Add to merged dict\n",
+        "        merged_state_dict.update(layer_dict)\n",
+        "        converted += 1\n",
+        "\n",
+        "    print(f\"\\n✅ Successfully converted {converted} layers to individual files.\")\n",
+        "    print(f\"Individual layers saved in: {output_dir}\\n\")\n",
+        "\n",
+        "    # ====================== 2. CREATE FULL LORA FROM SAVED FILES ======================\n",
+        "    print(\"🔗 Merging all individual LoRA files into one full LoRA...\")\n",
+        "\n",
+        "    full_merged = {}\n",
+        "    individual_files = glob.glob(os.path.join(output_dir, \"*.safetensors\"))\n",
+        "\n",
+        "    for file_path in tqdm(individual_files, desc=\"Merging files\"):\n",
+        "        layer_dict = load_file(file_path, device=\"cpu\")\n",
+        "        full_merged.update(layer_dict)\n",
+        "\n",
+        "    # Save final full LoRA\n",
+        "    final_path = f\"/content/{final_lora_name}\"\n",
+        "    save_file(full_merged, final_path)\n",
+        "\n",
+        "    size_mb = os.path.getsize(final_path) / (1024 * 1024)\n",
+        "    print(f\"\\n🎉 Full LoRA successfully created!\")\n",
+        "    print(f\"   Path: {final_path}\")\n",
+        "    print(f\"   Size: {size_mb:.2f} MB\")\n",
+        "    print(f\"   Total keys: {len(full_merged)}\")\n",
+        "\n",
+        "    return output_dir, final_path\n",
+        "\n",
+        "\n",
+        "# ====================== RUN THE SCRIPT ======================\n",
+        "if __name__ == \"__main__\":\n",
+        "    output_dir, full_lora_path = convert_lokr_to_lora(\n",
+        "        repo_id=\"codeShare/flux-klein-9B-loras\",\n",
+        "        lokr_filename=\"klein9b_snofs_v1.safetensors\",\n",
+        "        output_dir=\"/content/lora_individual_layers\",\n",
+        "        final_lora_name=\"klein9b_snofs_v1_full_lora.safetensors\",\n",
+        "        target_rank=32,          # Try 192 or 256 if quality is insufficient\n",
+        "        hf_token=None             # Add your HF token if needed\n",
+        "    )\n",
+        "\n",
+        "    print(\"\\nAll done! You can now use the full LoRA file:\")\n",
+        "    print(f\"→ {full_lora_path}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch\n",
+        "import os\n",
+        "from safetensors.torch import load_file, save_file\n",
+        "from huggingface_hub import hf_hub_download\n",
+        "from collections import defaultdict\n",
+        "from tqdm import tqdm\n",
+        "import math\n",
+        "import glob\n",
+        "\n",
+        "\n",
+        "def convert_lokr_to_lora(\n",
+        "    repo_id: str = \"codeShare/flux-klein-9B-loras\",\n",
+        "    lokr_filename: str = \"klein9b_snofs_v1.safetensors\",\n",
+        "    output_dir: str = \"/content/lora_individual_layers\",\n",
+        "    final_lora_name: str = \"klein9b_snofs_v1_full_lora.safetensors\",\n",
+        "    target_rank: int = 128,\n",
+        "    min_rank: int = 32,           # ← Prevents rank collapse\n",
+        "    alpha_clip: float = 1.0,      # ← Safety for huge alpha values\n",
+        "    hf_token: str = None\n",
+        "):\n",
+        "    device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+        "    print(f\"✅ Using device: {device}\\n\")\n",
+        "\n",
+        "    # ====================== DOWNLOAD & LOAD LoKr ======================\n",
+        "    lokr_path = hf_hub_download(repo_id=repo_id, filename=lokr_filename, token=hf_token, local_dir=\"/content\")\n",
+        "    print(f\"Loading LoKr: {lokr_path}\")\n",
+        "    state_dict = load_file(lokr_path, device=\"cpu\")\n",
+        "\n",
+        "    print(f\"Total keys in original LoKr: {len(state_dict)}\\n\")\n",
+        "\n",
+        "    modules = defaultdict(dict)\n",
+        "\n",
+        "    # Parse modules\n",
+        "    for key, tensor in state_dict.items():\n",
+        "        if key.endswith('.alpha'):\n",
+        "            base = key[:-6]\n",
+        "            alpha_val = float(tensor.item())\n",
+        "            # Safety clamp on alpha\n",
+        "            modules[base]['alpha'] = max(0.01, min(alpha_val, alpha_clip))\n",
+        "            continue\n",
+        "        if '.lokr_' in key:\n",
+        "            base = key.split('.lokr_')[0]\n",
+        "            part = key.split('.')[-1]\n",
+        "            modules[base][part] = tensor\n",
+        "\n",
+        "    print(f\"Detected {len(modules)} LoKr modules.\\n\")\n",
+        "\n",
+        "    os.makedirs(output_dir, exist_ok=True)\n",
+        "\n",
+        "    merged_state_dict = {}\n",
+        "    converted = 0\n",
+        "\n",
+        "    print(\"🔄 Converting LoKr → LoRA layers with minimum rank enforcement...\")\n",
+        "\n",
+        "    for base_key, weights in tqdm(modules.items(), desc=\"Converting\"):\n",
+        "        alpha = weights.get('alpha', 1.0)\n",
+        "\n",
+        "        if 'lokr_w1' not in weights or 'lokr_w2' not in weights:\n",
+        "            print(f\"⚠️ Skipping {base_key} (missing w1/w2)\")\n",
+        "            continue\n",
+        "\n",
+        "        w1 = weights['lokr_w1'].to(device, dtype=torch.float32)\n",
+        "        w2 = weights['lokr_w2'].to(device, dtype=torch.float32)\n",
+        "\n",
+        "        # Kronecker product\n",
+        "        delta = torch.kron(w1, w2)\n",
+        "\n",
+        "        # SVD\n",
+        "        U, S, Vh = torch.linalg.svd(delta, full_matrices=False)\n",
+        "\n",
+        "        # === FORCE MINIMUM RANK ===\n",
+        "        possible_rank = min(S.shape[0], target_rank)\n",
+        "        r = max(min_rank, possible_rank)\n",
+        "\n",
+        "        sqrt_s = S[:r].sqrt().unsqueeze(1)\n",
+        "\n",
+        "        # Standard LoRA convention for Flux / SDXL / etc.\n",
+        "        lora_A = (sqrt_s.T @ Vh[:r, :])          # (rank, in_features)\n",
+        "        lora_B = (U[:, :r] @ sqrt_s)             # (out_features, rank)\n",
+        "\n",
+        "        scale = alpha / math.sqrt(r)\n",
+        "\n",
+        "        lora_A = (lora_A * scale).to(torch.bfloat16).cpu()\n",
+        "        lora_B = (lora_B * scale).to(torch.bfloat16).cpu()\n",
+        "\n",
+        "        print(f\"  {base_key:65} | w1={w1.shape} | w2={w2.shape} | α={alpha:.3f} | rank={r:3d}\")\n",
+        "\n",
+        "        # Individual layer dictionary\n",
+        "        layer_dict = {\n",
+        "            f\"{base_key}.lora_A.weight\": lora_A,\n",
+        "            f\"{base_key}.lora_B.weight\": lora_B,\n",
+        "        }\n",
+        "\n",
+        "        # Save individual safetensors file\n",
+        "        safe_name = base_key.replace(\".\", \"_\").replace(\"/\", \"_\")\n",
+        "        layer_path = os.path.join(output_dir, f\"{safe_name}.safetensors\")\n",
+        "        save_file(layer_dict, layer_path)\n",
+        "\n",
+        "        # Add to final merged dict\n",
+        "        merged_state_dict.update(layer_dict)\n",
+        "        converted += 1\n",
+        "\n",
+        "    # ====================== CREATE FULL LORA ======================\n",
+        "    print(f\"\\n🔗 Saving full merged LoRA ({len(merged_state_dict)} keys)...\")\n",
+        "    final_path = f\"/content/{final_lora_name}\"\n",
+        "    save_file(merged_state_dict, final_path)\n",
+        "\n",
+        "    size_mb = os.path.getsize(final_path) / (1024 * 1024)\n",
+        "    print(f\"\\n🎉 Conversion completed!\")\n",
+        "    print(f\"   Converted layers : {converted}\")\n",
+        "    print(f\"   Full LoRA path   : {final_path}\")\n",
+        "    print(f\"   File size        : {size_mb:.2f} MB\")\n",
+        "    print(f\"   Individual layers: {output_dir}/\")\n",
+        "\n",
+        "    return output_dir, final_path\n",
+        "\n",
+        "\n",
+        "# ====================== RUN ======================\n",
+        "if __name__ == \"__main__\":\n",
+        "    output_dir, full_lora_path = convert_lokr_to_lora(\n",
+        "        repo_id=\"codeShare/flux-klein-9B-loras\",\n",
+        "        lokr_filename=\"klein9b_snofs_v1.safetensors\",\n",
+        "        output_dir=\"/content/lora_individual_layers\",\n",
+        "        final_lora_name=\"klein9b_snofs_v1_full_lora.safetensors\",\n",
+        "        target_rank=32,\n",
+        "        min_rank=8,          # Change to 16, 48, or 64 depending on quality\n",
+        "        alpha_clip=100,       # Try 0.5 or 2.0 if the model is too strong/weak\n",
+        "        hf_token=None\n",
+        "    )\n",
+        "\n",
+        "    print(\"\\n✅ Done! You can now use:\")\n",
+        "    print(f\"   → {full_lora_path}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "F1yPQS7Dg2fD",
+        "outputId": "3c4593c8-5f1b-4bed-b8df-3057174dd894"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "✅ Using device: cuda\n",
+            "\n",
+            "Loading LoKr: /content/klein9b_snofs_v1.safetensors\n",
+            "Total keys in original LoKr: 336\n",
+            "\n",
+            "Detected 112 LoKr modules.\n",
+            "\n",
+            "🔄 Converting LoKr → LoRA layers with minimum rank enforcement...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Converting:   1%|          | 1/112 [00:11<21:47, 11.78s/it]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "  diffusion_model.double_blocks.0.img_attn.proj                     | w1=torch.Size([4, 4]) | w2=torch.Size([1024, 1024]) | α=100.000 | rank= 32\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\rConverting:   2%|▏         | 2/112 [00:23<21:43, 11.85s/it]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "  diffusion_model.double_blocks.0.img_attn.qkv                      | w1=torch.Size([4, 4]) | w2=torch.Size([3072, 1024]) | α=100.000 | rank= 32\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\rConverting:   3%|▎         | 3/112 [00:36<22:05, 12.16s/it]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "  diffusion_model.double_blocks.0.img_mlp.0                         | w1=torch.Size([4, 4]) | w2=torch.Size([6144, 1024]) | α=100.000 | rank= 32\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\rConverting:   4%|▎         | 4/112 [00:46<20:47, 11.56s/it]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "  diffusion_model.double_blocks.0.img_mlp.2                         | w1=torch.Size([4, 4]) | w2=torch.Size([1024, 3072]) | α=100.000 | rank= 32\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\rConverting:   4%|▍         | 5/112 [00:58<20:39, 11.58s/it]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "  diffusion_model.double_blocks.0.txt_attn.proj                     | w1=torch.Size([4, 4]) | w2=torch.Size([1024, 1024]) | α=100.000 | rank= 32\n"
+          ]
+        }
+      ]
+    }
+  ]
+}