Upload lora_forward_pass_test.ipynb

lora_forward_pass_test.ipynb

@@ -2466,13 +2466,10 @@
       ],
       "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",
@@ -2485,7 +2482,6 @@
         "\n",
         "import torchao\n",
         "print(f\"✅ torchao updated to version: {torchao.__version__}\")\n",
-        "\n",
         "!pip install -q safetensors huggingface_hub diffusers transformers accelerate sdnq\n",
         "\n",
         "#images for testing\n",
@@ -2498,9 +2494,7 @@
         "prompt1= 'a cute dog on grass'\n",
         "prompt2 = 'a golden retriever on a road'\n",
         "#-----#\n",
-        "\n",
         "print(\"✅ Dependencies installed\")\n",
-        "\n",
         "print(\"✅ Logged into Hugging Face\")\n",
         "\n",
         "import gc\n",
@@ -2518,11 +2512,9 @@
         "from huggingface_hub import hf_hub_download\n",
         "import hashlib\n",
         "from pathlib import Path\n",
-        "\n",
         "import torch\n",
         "from transformers import BitsAndBytesConfig\n",
         "\n",
-        "\n",
         "# Patch function\n",
         "def patch_encode_prompt(pipe, cached_prompt_embeds, cached_text_ids, gpu_id):\n",
         "    def patched(self, prompt=None, device=None, num_images_per_prompt=1, prompt_embeds=None, **kwargs):\n",
@@ -2540,15 +2532,12 @@
         "    pipe.encode_prompt = partial(patched, pipe)\n",
         "    return pipe\n",
         "\n",
-        "\n",
         "# Load single pipe\n",
         "def load_klein_pipe(gpu_id: int, pipe_id: int):\n",
         "    torch.cuda.set_device(gpu_id)\n",
-        "\n",
         "    print(f\" [GPU {gpu_id} - Pipe {pipe_id}] Loading...\")\n",
-        "\n",
         "    MODEL_ID = 'codeShare/Flux.2-Klein-4B-SDNQ-4bit'\n",
-        "\n",
+        "    #----#\n",
         "    edit_prompt = 'this is a test'\n",
         "    pipe = Flux2KleinPipeline.from_pretrained(\n",
         "        MODEL_ID,\n",
@@ -2575,7 +2564,6 @@
         "    #-----#\n",
         "    gc.collect()\n",
         "    torch.cuda.empty_cache()\n",
-        "\n",
         "    pipe.transformer.to(f\"cuda:{gpu_id}\")\n",
         "    # pipe.enable_model_cpu_offload(gpu_id=gpu_id) # Removed: This can interfere with VAE device placement during training\n",
         "\n",
@@ -2584,7 +2572,6 @@
         "    #pipe.vae.enable_slicing()\n",
         "    #pipe.vae.enable_tiling()\n",
         "    #pipe.enable_attention_slicing(1)\n",
-        "\n",
         "    print(f\" [GPU {gpu_id} - Pipe {pipe_id}] Ready | VRAM: {torch.cuda.memory_allocated(gpu_id)/1e9:.2f} GB\")\n",
         "    return pipe\n",
         "#----#\n"
@@ -2596,10 +2583,35 @@
         "gc.collect()\n",
         "torch.cuda.empty_cache()\n",
         "NUM_GPUS = torch.cuda.device_count()\n",
-        "PIPE_NUM = 1\n",
-        "for gpu in range(NUM_GPUS):\n",
-        "  pipe = load_klein_pipe(gpu , PIPE_NUM)\n",
-        "  print(f'loaded pipe to {pipe.device}')"
+        "#----#\n",
+        "PIPE_ID = 1\n",
+        "GPU_ID = 0\n",
+        "pipe = load_klein_pipe(GPU_ID , PIPE_ID)\n",
+        "print(f'loaded pipe to {pipe.device}')\n",
+        "#----#\n",
+        "pipe.transformer = pipe.transformer.to('cuda')\n",
+        "gc.collect()\n",
+        "torch.cuda.empty_cache()\n",
+        "from peft import prepare_model_for_kbit_training\n",
+        "pipe.transformer = prepare_model_for_kbit_training(pipe.transformer)\n",
+        "#----#\n",
+        "from peft import LoraConfig\n",
+        "config = LoraConfig(\n",
+        "    r=16,\n",
+        "    lora_alpha=8,\n",
+        "    target_modules=[\n",
+        "    \"attn.to_q\", \"attn.to_k\", \"attn.to_v\",\n",
+        "    \"ff.linear_in\", \"ff.linear_out\",\n",
+        "    \"ff_context.linear_in\", \"ff_context.linear_out\",\n",
+        "    \"attn.to_qkv_mlp_proj\",\n",
+        "],\n",
+        "    lora_dropout=0.05,\n",
+        "    bias=\"none\",\n",
+        ")\n",
+        "#----#\n",
+        "from peft import get_peft_model\n",
+        "pipe.transformer = get_peft_model(pipe.transformer, config)\n",
+        "pipe.transformer.print_trainable_parameters()"
       ],
       "metadata": {
         "colab": {
@@ -2762,81 +2774,6 @@
         }
       ]
     },
-    {
-      "cell_type": "code",
-      "source": [
-        "pipe.transformer = pipe.transformer.to('cuda')\n",
-        "gc.collect()\n",
-        "torch.cuda.empty_cache()\n",
-        "from peft import prepare_model_for_kbit_training\n",
-        "pipe.transformer = prepare_model_for_kbit_training(pipe.transformer)"
-      ],
-      "metadata": {
-        "id": "sEhh282dy1Ls"
-      },
-      "execution_count": 3,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "from peft import LoraConfig\n",
-        "\n",
-        "config = LoraConfig(\n",
-        "    r=16,\n",
-        "    lora_alpha=8,\n",
-        "    target_modules=[\n",
-        "    \"attn.to_q\", \"attn.to_k\", \"attn.to_v\",\n",
-        "    \"ff.linear_in\", \"ff.linear_out\",\n",
-        "    \"ff_context.linear_in\", \"ff_context.linear_out\",\n",
-        "    \"attn.to_qkv_mlp_proj\",\n",
-        "],\n",
-        "    lora_dropout=0.05,\n",
-        "    bias=\"none\",\n",
-        ")"
-      ],
-      "metadata": {
-        "id": "7w3yiYzhuo0A"
-      },
-      "execution_count": 4,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "from peft import get_peft_model\n",
-        "\n",
-        "pipe.transformer = get_peft_model(pipe.transformer, config)"
-      ],
-      "metadata": {
-        "id": "qTSuLZU7uzTk"
-      },
-      "execution_count": 5,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "pipe.transformer.print_trainable_parameters()"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "_6k8-Z0twPn-",
-        "outputId": "3f3cc893-1e91-4b77-8121-7a741ae177dd"
-      },
-      "execution_count": 6,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "trainable params: 16,711,680 || all params: 2,167,021,056 || trainable%: 0.7712\n"
-          ]
-        }
-      ]
-    },
     {
       "cell_type": "code",
       "source": [
@@ -2875,7 +2812,17 @@
         "\n",
         "    def __getitem__(self, idx):\n",
         "        image = self.transform(self.images[idx])\n",
-        "        return image, self.prompts[idx]\n",
+        "        return image, self.prompts[idx]"
+      ],
+      "metadata": {
+        "id": "7LIOh4CwyxIK"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
         "\n",
         "dataset = Flux2KleinDataset(image_paths, instance_prompts, resolution=512)\n",
         "dataloader = DataLoader(dataset, batch_size=1, shuffle=True)\n",
@@ -2883,14 +2830,39 @@
         "# ====================== TRAINING SETUP ======================\n",
         "device = pipe.device\n",
         "dtype = torch.float16  # or bfloat16 if supported\n",
+        "from sdnq.training import convert_sdnq_model_to_training\n",
+        "from sdnq.common import use_torch_compile as triton_is_available\n",
+        "pipe.transformer = convert_sdnq_model_to_training(\n",
+        "    pipe.transformer,\n",
+        "    quantized_matmul_dtype=\"int8\",\n",
+        "    use_grad_ckpt=True,\n",
+        "    use_quantized_matmul=False,\n",
+        "    use_stochastic_rounding=True,\n",
+        "    dequantize_fp32=True,\n",
+        ")\n",
         "\n",
-        "pipe.vae.to(device, dtype=dtype)\n",
-        "pipe.transformer.train()\n",
-        "\n",
-        "# Optional: Enable gradient checkpointing for memory savings\n",
-        "#pipe.transformer.gradient_checkpointing_enable()\n",
+        "#----#\n",
         "\n",
-        "optimizer = torch.optim.AdamW(pipe.transformer.parameters(), lr=1e-4, weight_decay=0.01)\n",
+        "from sdnq.optim import Adafactor, AdamW, CAME, Lion, Muon\n",
+        "optimizer = AdamW(\n",
+        "    parameters,\n",
+        "    use_quantized_buffers=True,\n",
+        "    quantized_buffers_dtype=\"uint8\",\n",
+        "    quantized_buffers_hadamard_group_size=128,\n",
+        "    quantized_buffers_group_size=32,\n",
+        "    quantized_buffers_svd_rank=32,\n",
+        "    final_norm_mode=\"clip\", # can be one of [\"none\", \"clip\", \"rms\", \"rms_clip\", \"relative\", \"muon\"]\n",
+        "    use_kahan=False,\n",
+        "    use_cautious=False,\n",
+        "    use_stochastic_rounding=True,\n",
+        "    use_stochastic_buffers=True,\n",
+        "    quantized_buffers_use_svd=False,\n",
+        "    quantized_buffers_use_hadamard=False,\n",
+        "    use_torch_compile=False,\n",
+        "    offload_buffers=False,\n",
+        "    offload_non_blocking=True,\n",
+        ")\n",
+        "#----#\n",
         "num_epochs = 5\n",
         "accumulation_steps = 2\n",
         "\n",
@@ -2908,7 +2880,7 @@
         "        with torch.no_grad():\n",
         "            # FLUX VAE expects [-1, 1]\n",
         "            latents = pipe.vae.encode(image * 2 - 1).latent_dist.sample()\n",
-        "            # No scaling factor as per your note\n",
+        "            # No scaling factor should be used for flux klein 4B\n",
         "\n",
         "        # ====================== TEXT ENCODING ======================\n",
         "        with torch.no_grad():\n",