Upload run_flux3_klein_sdnq.ipynb

run_flux3_klein_sdnq.ipynb

@@ -0,0 +1,2313 @@
+{
+  "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": "markdown",
+      "source": [
+        "# lwkenf"
+      ],
+      "metadata": {
+        "id": "x-5cE_4iH91I"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# =============================================================================\n",
+        "# ENCODE IMAGES – FLUX 3 Image Klein (SDNQ int4)\n",
+        "# Repo: https://huggingface.co/codeShare/flux-3-image-klein-sdnq-int4\n",
+        "# =============================================================================\n",
+        "\n",
+        "from google.colab import drive\n",
+        "import os\n",
+        "import shutil\n",
+        "import zipfile\n",
+        "import glob\n",
+        "from PIL import Image\n",
+        "import io\n",
+        "import hashlib\n",
+        "import json\n",
+        "from google.colab import files\n",
+        "\n",
+        "!pip install -q pynacl\n",
+        "\n",
+        "from nacl.secret import SecretBox\n",
+        "from nacl.utils import random\n",
+        "\n",
+        "# Mount Drive\n",
+        "drive.mount('/content/drive', force_remount=True)\n",
+        "\n",
+        "# =============================================================================\n",
+        "#@markdown ### 🔧 Encrypt settings (FLUX 3 Image Klein + optional LoRA)\n",
+        "# =============================================================================\n",
+        "foreground_images_zip_path = '/content/drive/MyDrive/sm_merged.zip' #@param {type:\"string\"}\n",
+        "upload_foreground_manually = False #@param {type:\"boolean\"}\n",
+        "\n",
+        "background_images_zip_path = '/content/drive/MyDrive/backgrounds.zip' #@param {type:\"string\"}\n",
+        "upload_background_manually = False #@param {type:\"boolean\"}\n",
+        "\n",
+        "encryption_password = \"banana\" #@param {type:\"string\"}\n",
+        "\n",
+        "output_drive_base_path = \"/content/drive/MyDrive/\" #@param {type:\"string\"}\n",
+        "output_folder_name = \"my_flux_dataset\" #@param {type:\"string\"}\n",
+        "\n",
+        "# Additional config values\n",
+        "MODEL_ID = \"codeShare/flux-3-image-klein-sdnq-int4\" #@param ['codeShare/flux-3-image-klein-sdnq-int4']\n",
+        "edit_prompt = \"remove the white background. as a real photo this girl has bare skin. put this character on the color gradient background. add diagonal border with dark gray background. the background has a stylish pattern.\" #@param {type:\"string\"}\n",
+        "resolution = \"1024 x 1024 (Square)\" #@param {type:\"string\"}\n",
+        "\n",
+        "# LORA Settings (update repo / names when you have Flux-3 compatible LoRAs)\n",
+        "lora_name = \"No LoRa\" #@param [\"No LoRa\"]\n",
+        "lora_strength = 0.8 #@param {type:\"slider\", min:0, max:2, step:0.1}\n",
+        "\n",
+        "# =============================================================================\n",
+        "# ===== KEY DERIVATION =====\n",
+        "# =============================================================================\n",
+        "def derive_key(password):\n",
+        "    return hashlib.sha256(password.encode()).digest()\n",
+        "\n",
+        "SECRET_KEY = derive_key(encryption_password)\n",
+        "box = SecretBox(SECRET_KEY)\n",
+        "\n",
+        "# =============================================================================\n",
+        "# ===== IMAGE → BYTES =====\n",
+        "# =============================================================================\n",
+        "def pil_to_bytes(img):\n",
+        "    buf = io.BytesIO()\n",
+        "    img.save(buf, format=\"JPEG\", quality=95)\n",
+        "    return buf.getvalue()\n",
+        "\n",
+        "# =============================================================================\n",
+        "# ===== ENCRYPT =====\n",
+        "# =============================================================================\n",
+        "def encrypt_bytes(data):\n",
+        "    nonce = random(SecretBox.NONCE_SIZE)\n",
+        "    return box.encrypt(data, nonce)\n",
+        "\n",
+        "# =============================================================================\n",
+        "# ====================== PROCESS AND ENCRYPT ZIP ======================\n",
+        "# =============================================================================\n",
+        "def process_and_encrypt_zip(input_zip_filepath, output_encrypted_zip_name, output_base_path, secret_box_instance):\n",
+        "    print(f\"\\n📦 Extracting images from {os.path.basename(input_zip_filepath)}...\")\n",
+        "    func_temp_extract_dir = f'/content/func_temp_extract_{os.path.basename(input_zip_filepath).replace(\".zip\", \"\")}'\n",
+        "\n",
+        "    if os.path.exists(func_temp_extract_dir):\n",
+        "        shutil.rmtree(func_temp_extract_dir)\n",
+        "    os.makedirs(func_temp_extract_dir, exist_ok=True)\n",
+        "\n",
+        "    try:\n",
+        "        with zipfile.ZipFile(input_zip_filepath, 'r') as z:\n",
+        "            z.extractall(func_temp_extract_dir)\n",
+        "    except FileNotFoundError:\n",
+        "        print(f\"⚠️ Warning: Input zip file not found: {input_zip_filepath}. Skipping this zip.\")\n",
+        "        return\n",
+        "    except Exception as e:\n",
+        "        print(f\"❌ Error extracting {input_zip_filepath}: {e}. Skipping this zip.\")\n",
+        "        return\n",
+        "\n",
+        "    image_files = sorted(glob.glob(os.path.join(func_temp_extract_dir, '*.*')))\n",
+        "    image_files = [f for f in image_files if f.lower().endswith(('.png','.jpg','.jpeg','.webp','.gif'))]\n",
+        "\n",
+        "    print(f\"✅ Found {len(image_files)} images to encrypt in {os.path.basename(input_zip_filepath)}.\")\n",
+        "\n",
+        "    encrypted_image_data_for_zip = []\n",
+        "    for img_path in image_files:\n",
+        "        try:\n",
+        "            img = Image.open(img_path).convert(\"RGB\")\n",
+        "            img_bytes = pil_to_bytes(img)\n",
+        "            enc_msg = encrypt_bytes(img_bytes)\n",
+        "            encrypted_image_data_for_zip.append((os.path.basename(img_path), enc_msg))\n",
+        "        except Exception as e:\n",
+        "            print(f\"❌ Error processing image {os.path.basename(img_path)}: {e}\")\n",
+        "\n",
+        "    print(f\"🔐 Encrypted {len(encrypted_image_data_for_zip)} images from {os.path.basename(input_zip_filepath)}.\")\n",
+        "\n",
+        "    # Create encrypted zip\n",
+        "    temp_encrypted_zip_path = os.path.join('/content', f'temp_{output_encrypted_zip_name}')\n",
+        "\n",
+        "    with zipfile.ZipFile(temp_encrypted_zip_path, 'w') as ez:\n",
+        "        for original_fname, enc_msg in encrypted_image_data_for_zip:\n",
+        "            encrypted_filename = f\"{os.path.splitext(original_fname)[0]}_encrypted.bin\"\n",
+        "            combined_bytes = enc_msg.nonce + enc_msg.ciphertext\n",
+        "            ez.writestr(encrypted_filename, combined_bytes)\n",
+        "\n",
+        "    final_zip_path = os.path.join(output_base_path, output_encrypted_zip_name)\n",
+        "    shutil.move(temp_encrypted_zip_path, final_zip_path)\n",
+        "\n",
+        "    print(f\"✅ Saved: {final_zip_path}\")\n",
+        "\n",
+        "    if os.path.exists(func_temp_extract_dir):\n",
+        "        shutil.rmtree(func_temp_extract_dir)\n",
+        "\n",
+        "\n",
+        "# =============================================================================\n",
+        "# ====================== CREATE OUTPUT FOLDER ======================\n",
+        "# =============================================================================\n",
+        "output_drive_full_path = os.path.join(output_drive_base_path, output_folder_name)\n",
+        "os.makedirs(output_drive_full_path, exist_ok=True)\n",
+        "\n",
+        "print(f\"📁 Output folder created: {output_drive_full_path}\")\n",
+        "\n",
+        "# =============================================================================\n",
+        "# ====================== PROCESS BOTH ZIPS ======================\n",
+        "# =============================================================================\n",
+        "\n",
+        "# --- Foreground Images ---\n",
+        "current_foreground_zip_path = foreground_images_zip_path\n",
+        "uploaded_fg_filename = None\n",
+        "uploaded_fg_temp_zip = None\n",
+        "fg_temp_dir = \"/content/temp_fg_images_individual_upload\"\n",
+        "\n",
+        "if upload_foreground_manually:\n",
+        "    print(\"\\n📤 Upload your foreground images (zip or individual files):\")\n",
+        "    uploaded = files.upload()\n",
+        "    if uploaded:\n",
+        "        zip_file_uploaded = False\n",
+        "        uploaded_files_list = list(uploaded.keys())\n",
+        "\n",
+        "        for fn in uploaded_files_list:\n",
+        "            if fn.endswith('.zip'):\n",
+        "                uploaded_fg_filename = fn\n",
+        "                zip_file_uploaded = True\n",
+        "                break\n",
+        "\n",
+        "        if zip_file_uploaded:\n",
+        "            current_foreground_zip_path = os.path.join('/content/', uploaded_fg_filename)\n",
+        "            print(f\"✅ Using uploaded foreground zip: {current_foreground_zip_path}\")\n",
+        "        elif uploaded_files_list:\n",
+        "            os.makedirs(fg_temp_dir, exist_ok=True)\n",
+        "            for fname, data in uploaded.items():\n",
+        "                with open(os.path.join(fg_temp_dir, fname), 'wb') as f:\n",
+        "                    f.write(data)\n",
+        "            uploaded_fg_temp_zip = \"/content/temp_foreground_images_from_individual.zip\"\n",
+        "            with zipfile.ZipFile(uploaded_fg_temp_zip, 'w') as zf:\n",
+        "                for root, _, files_in_dir in os.walk(fg_temp_dir):\n",
+        "                    for file in files_in_dir:\n",
+        "                        zf.write(os.path.join(root, file), os.path.basename(file))\n",
+        "            current_foreground_zip_path = uploaded_fg_temp_zip\n",
+        "            print(f\"✅ Using uploaded individual foreground images (temporarily zipped)\")\n",
+        "        else:\n",
+        "            print(\"⚠️ No foreground files uploaded. Falling back to Drive path.\")\n",
+        "    else:\n",
+        "        print(\"⚠️ No foreground files uploaded. Falling back to Drive path.\")\n",
+        "\n",
+        "process_and_encrypt_zip(current_foreground_zip_path, \"foregrounds.zip\", output_drive_full_path, box)\n",
+        "if upload_foreground_manually and uploaded_fg_filename and os.path.exists(current_foreground_zip_path):\n",
+        "    os.remove(current_foreground_zip_path)\n",
+        "if upload_foreground_manually and uploaded_fg_temp_zip and os.path.exists(uploaded_fg_temp_zip):\n",
+        "    os.remove(uploaded_fg_temp_zip)\n",
+        "    shutil.rmtree(fg_temp_dir, ignore_errors=True)\n",
+        "\n",
+        "# --- Background Images ---\n",
+        "current_background_zip_path = background_images_zip_path\n",
+        "uploaded_bg_filename = None\n",
+        "uploaded_bg_temp_zip = None\n",
+        "bg_temp_dir = \"/content/temp_bg_images_individual_upload\"\n",
+        "\n",
+        "if upload_background_manually:\n",
+        "    print(\"\\n📤 Upload your background images (zip or individual files):\")\n",
+        "    uploaded = files.upload()\n",
+        "    if uploaded:\n",
+        "        zip_file_uploaded = False\n",
+        "        uploaded_files_list = list(uploaded.keys())\n",
+        "\n",
+        "        for fn in uploaded_files_list:\n",
+        "            if fn.endswith('.zip'):\n",
+        "                uploaded_bg_filename = fn\n",
+        "                zip_file_uploaded = True\n",
+        "                break\n",
+        "\n",
+        "        if zip_file_uploaded:\n",
+        "            current_background_zip_path = os.path.join('/content/', uploaded_bg_filename)\n",
+        "            print(f\"✅ Using uploaded background zip: {current_background_zip_path}\")\n",
+        "        elif uploaded_files_list:\n",
+        "            os.makedirs(bg_temp_dir, exist_ok=True)\n",
+        "            for fname, data in uploaded.items():\n",
+        "                with open(os.path.join(bg_temp_dir, fname), 'wb') as f:\n",
+        "                    f.write(data)\n",
+        "            uploaded_bg_temp_zip = \"/content/temp_background_images_from_individual.zip\"\n",
+        "            with zipfile.ZipFile(uploaded_bg_temp_zip, 'w') as zf:\n",
+        "                for root, _, files_in_dir in os.walk(bg_temp_dir):\n",
+        "                    for file in files_in_dir:\n",
+        "                        zf.write(os.path.join(root, file), os.path.basename(file))\n",
+        "            current_background_zip_path = uploaded_bg_temp_zip\n",
+        "            print(f\"✅ Using uploaded individual background images (temporarily zipped)\")\n",
+        "        else:\n",
+        "            print(\"⚠️ No background files uploaded. Falling back to Drive path.\")\n",
+        "    else:\n",
+        "        print(\"⚠️ No background files uploaded. Falling back to Drive path.\")\n",
+        "\n",
+        "process_and_encrypt_zip(current_background_zip_path, \"backgrounds.zip\", output_drive_full_path, box)\n",
+        "if upload_background_manually and uploaded_bg_filename and os.path.exists(current_background_zip_path):\n",
+        "    os.remove(current_background_zip_path)\n",
+        "if upload_background_manually and uploaded_bg_temp_zip and os.path.exists(uploaded_bg_temp_zip):\n",
+        "    os.remove(uploaded_bg_temp_zip)\n",
+        "    shutil.rmtree(bg_temp_dir, ignore_errors=True)\n",
+        "\n",
+        "# =============================================================================\n",
+        "# ====================== SAVE CONFIG FILES ======================\n",
+        "# =============================================================================\n",
+        "print(\"\\n📝 Saving config files...\")\n",
+        "\n",
+        "password_txt_path = os.path.join(output_drive_full_path, \"password.txt\")\n",
+        "model_id_path = os.path.join(output_drive_full_path, \"model_id.txt\")\n",
+        "resolution_path = os.path.join(output_drive_full_path, \"resolution.txt\")\n",
+        "edit_prompt_path = os.path.join(output_drive_full_path, \"edit_prompt.txt\")\n",
+        "lora_config_path = os.path.join(output_drive_full_path, \"include_lora_strength.json\")\n",
+        "\n",
+        "with open(password_txt_path, 'w', encoding='utf-8') as f:\n",
+        "    f.write(encryption_password)\n",
+        "\n",
+        "with open(model_id_path, 'w', encoding='utf-8') as f:\n",
+        "    f.write(MODEL_ID)\n",
+        "\n",
+        "with open(resolution_path, 'w', encoding='utf-8') as f:\n",
+        "    f.write(resolution)\n",
+        "\n",
+        "with open(edit_prompt_path, 'w', encoding='utf-8') as f:\n",
+        "    f.write(edit_prompt)\n",
+        "\n",
+        "lora_config_data = {\n",
+        "    \"lora_name\": lora_name,\n",
+        "    \"lora_strength\": lora_strength,\n",
+        "    \"lora_base_model\": \"flux3_klein\",\n",
+        "    \"repo_id\": \"\"   # fill when you have Flux-3 compatible LoRAs\n",
+        "}\n",
+        "\n",
+        "with open(lora_config_path, 'w', encoding='utf-8') as f:\n",
+        "    json.dump(lora_config_data, f, indent=4)\n",
+        "\n",
+        "print(f\"🔑 Saved: {password_txt_path}\")\n",
+        "print(f\"🧠 Saved: {model_id_path}\")\n",
+        "print(f\"📐 Saved: {resolution_path}\")\n",
+        "print(f\"✏️  Saved: {edit_prompt_path}\")\n",
+        "print(f\"⚙️  Saved: {lora_config_path}\")\n",
+        "\n",
+        "print(\"\\n🎉 DONE! Files saved to Google Drive:\")\n",
+        "print(f\"   📂 {output_drive_full_path}/\")\n",
+        "print(f\"      • foregrounds.zip\")\n",
+        "print(f\"      • backgrounds.zip\")\n",
+        "print(f\"      • password.txt\")\n",
+        "print(f\"      • model_id.txt\")\n",
+        "print(f\"      • edit_prompt.txt\")\n",
+        "print(f\"      • resolution.txt\")\n",
+        "print(f\"      • include_lora_strength.json\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "TQGmIN8T0jyO",
+        "outputId": "629228a5-f76d-42e3-9bb4-6600a4efe36f"
+      },
+      "execution_count": 1,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mounted at /content/drive\n",
+            "📁 Output folder created: /content/drive/MyDrive/my_flux_dataset\n",
+            "\n",
+            "📦 Extracting images from sm_merged.zip...\n",
+            "✅ Found 7 images to encrypt in sm_merged.zip.\n",
+            "🔐 Encrypted 7 images from sm_merged.zip.\n",
+            "✅ Saved: /content/drive/MyDrive/my_flux_dataset/foregrounds.zip\n",
+            "\n",
+            "📦 Extracting images from backgrounds.zip...\n",
+            "⚠️ Warning: Input zip file not found: /content/drive/MyDrive/backgrounds.zip. Skipping this zip.\n",
+            "\n",
+            "📝 Saving config files...\n",
+            "🔑 Saved: /content/drive/MyDrive/my_flux_dataset/password.txt\n",
+            "🧠 Saved: /content/drive/MyDrive/my_flux_dataset/model_id.txt\n",
+            "📐 Saved: /content/drive/MyDrive/my_flux_dataset/resolution.txt\n",
+            "✏️  Saved: /content/drive/MyDrive/my_flux_dataset/edit_prompt.txt\n",
+            "⚙️  Saved: /content/drive/MyDrive/my_flux_dataset/include_lora_strength.json\n",
+            "\n",
+            "🎉 DONE! Files saved to Google Drive:\n",
+            "   📂 /content/drive/MyDrive/my_flux_dataset/\n",
+            "      • foregrounds.zip\n",
+            "      • backgrounds.zip\n",
+            "      • password.txt\n",
+            "      • model_id.txt\n",
+            "      • edit_prompt.txt\n",
+            "      • resolution.txt\n",
+            "      • include_lora_strength.json\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# =============================================================================\n",
+        "# CELL 2: VERIFY ENVIRONMENT\n",
+        "# =============================================================================\n",
+        "\n",
+        "import sys\n",
+        "import torch\n",
+        "import triton\n",
+        "import transformers\n",
+        "import diffusers\n",
+        "import sdnq\n",
+        "\n",
+        "print(\"=\" * 70)\n",
+        "print(\"ENVIRONMENT\")\n",
+        "print(\"=\" * 70)\n",
+        "\n",
+        "print(\"Python       :\", sys.version.split()[0])\n",
+        "print(\"Torch        :\", torch.__version__)\n",
+        "print(\"Torch CUDA   :\", torch.version.cuda)\n",
+        "print(\"Triton       :\", triton.__version__)\n",
+        "print(\"Transformers :\", transformers.__version__)\n",
+        "print(\"Diffusers    :\", diffusers.__version__)\n",
+        "print(\"SDNQ         :\", getattr(sdnq, \"__version__\", \"unknown\"))\n",
+        "\n",
+        "print()\n",
+        "print(\"=\" * 70)\n",
+        "print(\"GPU\")\n",
+        "print(\"=\" * 70)\n",
+        "\n",
+        "print(\"GPU          :\", torch.cuda.get_device_name(0))\n",
+        "print(\"CC           :\", torch.cuda.get_device_capability(0))\n",
+        "print(\"CUDA         :\", torch.cuda.is_available())\n",
+        "\n",
+        "if torch.cuda.is_available():\n",
+        "\n",
+        "    props = torch.cuda.get_device_properties(0)\n",
+        "\n",
+        "    print(\"VRAM         :\", round(props.total_memory / 1024**3, 2), \"GB\")\n",
+        "    print(\"BF16 reported:\", torch.cuda.is_bf16_supported())\n",
+        "\n",
+        "    major, minor = torch.cuda.get_device_capability(0)\n",
+        "\n",
+        "    if (major, minor) == (7, 5):\n",
+        "        print(\"✅ Tesla T4 / Turing SM75 detected\")\n",
+        "        print(\"✅ FP16 is the preferred runtime dtype\")\n",
+        "    else:\n",
+        "        print(\"⚠️ Unexpected GPU compute capability\")\n",
+        "\n",
+        "print(\"=\" * 70)\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Basic FP16 CUDA test\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "print(\"\\n🧪 Testing FP16 CUDA matmul...\")\n",
+        "\n",
+        "a = torch.randn(\n",
+        "    2048,\n",
+        "    2048,\n",
+        "    device=\"cuda\",\n",
+        "    dtype=torch.float16\n",
+        ")\n",
+        "\n",
+        "b = torch.randn(\n",
+        "    2048,\n",
+        "    2048,\n",
+        "    device=\"cuda\",\n",
+        "    dtype=torch.float16\n",
+        ")\n",
+        "\n",
+        "c = a @ b\n",
+        "\n",
+        "torch.cuda.synchronize()\n",
+        "\n",
+        "print(\"✅ FP16 CUDA matmul works\")\n",
+        "print(\"Result:\", c.shape, c.dtype)\n",
+        "\n",
+        "del a, b, c\n",
+        "\n",
+        "torch.cuda.empty_cache()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "AFPdlEod04s1",
+        "outputId": "214d95b4-2340-49f2-b65b-fde0f2c340d2"
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "WARNING:sdnq:SDNQ: OpenVINO MM kernels are not available! Falling back to PyTorch Eager kernels for CPU device. Error message: No module named 'openvino'\n",
+            "Unable to import `torchao` Tensor objects. This may affect loading checkpoints serialized with `torchao`\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "======================================================================\n",
+            "ENVIRONMENT\n",
+            "======================================================================\n",
+            "Python       : 3.13.16\n",
+            "Torch        : 2.11.0+cu130\n",
+            "Torch CUDA   : 13.0\n",
+            "Triton       : 3.6.0\n",
+            "Transformers : 5.22.1\n",
+            "Diffusers    : 0.42.0.dev0\n",
+            "SDNQ         : 0.2.8\n",
+            "\n",
+            "======================================================================\n",
+            "GPU\n",
+            "======================================================================\n",
+            "GPU          : Tesla T4\n",
+            "CC           : (7, 5)\n",
+            "CUDA         : True\n",
+            "VRAM         : 14.56 GB\n",
+            "BF16 reported: True\n",
+            "✅ Tesla T4 / Turing SM75 detected\n",
+            "✅ FP16 is the preferred runtime dtype\n",
+            "======================================================================\n",
+            "\n",
+            "🧪 Testing FP16 CUDA matmul...\n",
+            "✅ FP16 CUDA matmul works\n",
+            "Result: torch.Size([2048, 2048]) torch.float16\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# FLUX 3 KLEIN SDNQ\n",
+        "\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "3UdPl_hc-g-K"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# =============================================================================\n",
+        "# CELL 1: COLAB ENVIRONMENT\n",
+        "# T4 / SM75\n",
+        "# PyTorch 2.10 + CUDA 12.8\n",
+        "# Triton 3.6\n",
+        "# =============================================================================\n",
+        "\n",
+        "\n",
+        "# =============================================================================\n",
+        "# CELL 1 — T4 SAFE SDNQ ENVIRONMENT\n",
+        "# =============================================================================\n",
+        "\n",
+        "import os\n",
+        "\n",
+        "# Prevent SDNQ from selecting torch.compile/Triton optimization\n",
+        "os.environ[\"SDNQ_USE_TORCH_COMPILE\"] = \"0\"\n",
+        "\n",
+        "# Also prevent PyTorch/Inductor from compiling the SDNQ fallback.\n",
+        "os.environ[\"TORCH_COMPILE_DISABLE\"] = \"1\"\n",
+        "\n",
+        "# Useful for diagnostics\n",
+        "os.environ[\"TORCHDYNAMO_VERBOSE\"] = \"0\"\n",
+        "\n",
+        "print(\"SDNQ_USE_TORCH_COMPILE =\", os.environ[\"SDNQ_USE_TORCH_COMPILE\"])\n",
+        "print(\"TORCH_COMPILE_DISABLE   =\", os.environ[\"TORCH_COMPILE_DISABLE\"])\n",
+        "\n",
+        "\n",
+        "import os\n",
+        "import sys\n",
+        "import subprocess\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Install pinned PyTorch\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "print(\"\\n🔥 Installing PyTorch 2.10 CUDA 12.8...\")\n",
+        "\n",
+        "# =============================================================================\n",
+        "# PIN EXACT PYTORCH VERSION\n",
+        "# =============================================================================\n",
+        "\n",
+        "subprocess.run(\n",
+        "    [\n",
+        "        sys.executable,\n",
+        "        \"-m\",\n",
+        "        \"pip\",\n",
+        "        \"install\",\n",
+        "        \"--force-reinstall\",\n",
+        "        \"torch==2.10.0\",\n",
+        "        \"torchvision==0.25.0\",\n",
+        "        \"torchaudio==2.10.0\",\n",
+        "        \"--index-url\",\n",
+        "        \"https://download.pytorch.org/whl/cu128\",\n",
+        "    ],\n",
+        "    check=True,\n",
+        ")\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Triton\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "print(\"⚡ Installing Triton 3.6.0...\")\n",
+        "\n",
+        "subprocess.run(\n",
+        "    [\n",
+        "        sys.executable,\n",
+        "        \"-m\",\n",
+        "        \"pip\",\n",
+        "        \"install\",\n",
+        "        \"--upgrade\",\n",
+        "        \"triton\",\n",
+        "    ],\n",
+        "    check=True\n",
+        ")\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Diffusers\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "print(\"📦 Installing Diffusers...\")\n",
+        "\n",
+        "subprocess.run(\n",
+        "    [\n",
+        "        sys.executable,\n",
+        "        \"-m\",\n",
+        "        \"pip\",\n",
+        "        \"install\",\n",
+        "        \"--upgrade\",\n",
+        "        \"git+https://github.com/huggingface/diffusers.git\",\n",
+        "        \"--no-deps\",\n",
+        "    ],\n",
+        "    check=True\n",
+        ")\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Remaining packages\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "print(\"📦 Installing SDNQ + dependencies...\")\n",
+        "\n",
+        "subprocess.run(\n",
+        "    [\n",
+        "        sys.executable,\n",
+        "        \"-m\",\n",
+        "        \"pip\",\n",
+        "        \"install\",\n",
+        "        \"--upgrade\",\n",
+        "        \"sdnq\",\n",
+        "        \"torchao\",\n",
+        "        \"accelerate\",\n",
+        "        \"transformers\",\n",
+        "        \"sentencepiece\",\n",
+        "        \"safetensors\",\n",
+        "        \"huggingface_hub\",\n",
+        "        \"datasets\",\n",
+        "        \"pynacl\",\n",
+        "    ],\n",
+        "    check=True\n",
+        ")\n",
+        "\n",
+        "print(\"\\n\")\n",
+        "print(\"=\" * 70)\n",
+        "print(\"⚠️  INSTALLATION COMPLETE\")\n",
+        "print(\"=\" * 70)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "6hCNzUth0ksl",
+        "outputId": "305f2962-1637-448e-a53b-6779064835ee"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "SDNQ_USE_TORCH_COMPILE = 0\n",
+            "TORCH_COMPILE_DISABLE   = 1\n",
+            "\n",
+            "🔥 Installing PyTorch 2.10 CUDA 12.8...\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch\n",
+        "import sys\n",
+        "\n",
+        "print(\"=\" * 70)\n",
+        "print(\"ENVIRONMENT\")\n",
+        "print(\"=\" * 70)\n",
+        "\n",
+        "print(\"Python       :\", sys.version)\n",
+        "print(\"Torch        :\", torch.__version__)\n",
+        "print(\"Torch CUDA   :\", torch.version.cuda)\n",
+        "print(\"CUDA         :\", torch.cuda.is_available())\n",
+        "\n",
+        "if torch.cuda.is_available():\n",
+        "    print(\"GPU          :\", torch.cuda.get_device_name(0))\n",
+        "    print(\"CC           :\", torch.cuda.get_device_capability(0))\n",
+        "    print(\"VRAM         :\", round(\n",
+        "        torch.cuda.get_device_properties(0).total_memory / 1024**3,\n",
+        "        2\n",
+        "    ), \"GB\")\n",
+        "\n",
+        "print(\"=\" * 70)"
+      ],
+      "metadata": {
+        "id": "DBOGpo9BJhzZ"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# =============================================================================\n",
+        "# CELL 3: CONFIG + DATASET PATHS\n",
+        "# =============================================================================\n",
+        "\n",
+        "import os\n",
+        "import gc\n",
+        "import sys\n",
+        "import time\n",
+        "import math\n",
+        "import random\n",
+        "import warnings\n",
+        "import subprocess\n",
+        "import traceback\n",
+        "import re\n",
+        "import shutil\n",
+        "import importlib.util\n",
+        "import logging\n",
+        "from pathlib import Path\n",
+        "from collections import Counter\n",
+        "from huggingface_hub import login, HfApi\n",
+        "def free():\n",
+        "    gc.collect()\n",
+        "    torch.cuda.empty_cache()\n",
+        "#---#\n",
+        "free()\n",
+        "\n",
+        "import os\n",
+        "import gc\n",
+        "import json\n",
+        "import torch\n",
+        "\n",
+        "from pathlib import Path\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Dataset\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "google_drive_dataset_path = (\n",
+        "    \"/content/drive/MyDrive/my_flux_dataset\"\n",
+        ")\n",
+        "\n",
+        "dataset_path = Path(\n",
+        "    google_drive_dataset_path\n",
+        ")\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Mount Drive\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "from google.colab import drive\n",
+        "\n",
+        "drive.mount(\n",
+        "    \"/content/drive\",\n",
+        "    force_remount=True\n",
+        ")\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Hugging Face login\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "hf_token_path = (\n",
+        "    dataset_path /\n",
+        "    \"HF_TOKEN.txt\"\n",
+        ")\n",
+        "\n",
+        "hf_token = None\n",
+        "\n",
+        "if hf_token_path.exists():\n",
+        "\n",
+        "    hf_token = (\n",
+        "        hf_token_path\n",
+        "        .read_text(encoding=\"utf-8\")\n",
+        "        .strip()\n",
+        "    )\n",
+        "\n",
+        "    print(\"✅ HF_TOKEN loaded from dataset\")\n",
+        "\n",
+        "else:\n",
+        "\n",
+        "    print(\"⚠️ HF_TOKEN.txt not found\")\n",
+        "\n",
+        "    try:\n",
+        "\n",
+        "        from google.colab import userdata\n",
+        "\n",
+        "        hf_token = userdata.get(\"HF_TOKEN\")\n",
+        "\n",
+        "        if hf_token:\n",
+        "            print(\"✅ HF token loaded from Colab Secrets\")\n",
+        "\n",
+        "    except Exception:\n",
+        "        pass\n",
+        "\n",
+        "if hf_token:\n",
+        "\n",
+        "    from huggingface_hub import login\n",
+        "\n",
+        "    login(\n",
+        "        token=hf_token,\n",
+        "        add_to_git_credential=False\n",
+        "    )\n",
+        "\n",
+        "    print(\"✅ Hugging Face login complete\")\n",
+        "\n",
+        "else:\n",
+        "\n",
+        "    print(\"⚠️ No HF token — public models only\")\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Read configuration\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "MODEL_ID = (\n",
+        "    dataset_path /\n",
+        "    \"model_id.txt\"\n",
+        ").read_text(\n",
+        "    encoding=\"utf-8\"\n",
+        ").strip()\n",
+        "\n",
+        "edit_prompt = (\n",
+        "    dataset_path /\n",
+        "    \"edit_prompt.txt\"\n",
+        ").read_text(\n",
+        "    encoding=\"utf-8\"\n",
+        ").strip()\n",
+        "\n",
+        "resolution = (\n",
+        "    dataset_path /\n",
+        "    \"resolution.txt\"\n",
+        ").read_text(\n",
+        "    encoding=\"utf-8\"\n",
+        ").strip()\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# LoRA config\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "lora_config_path = (\n",
+        "    dataset_path /\n",
+        "    \"include_lora_strength.json\"\n",
+        ")\n",
+        "\n",
+        "if lora_config_path.exists():\n",
+        "\n",
+        "    with open(\n",
+        "        lora_config_path,\n",
+        "        \"r\",\n",
+        "        encoding=\"utf-8\"\n",
+        "    ) as f:\n",
+        "\n",
+        "        lora_data = json.load(f)\n",
+        "\n",
+        "else:\n",
+        "\n",
+        "    lora_data = {}\n",
+        "\n",
+        "lora_name_loaded = (\n",
+        "    lora_data.get(\n",
+        "        \"lora_name\",\n",
+        "        \"No LoRa\"\n",
+        "    )\n",
+        ")\n",
+        "\n",
+        "lora_strength_loaded = (\n",
+        "    lora_data.get(\n",
+        "        \"lora_strength\",\n",
+        "        0.8\n",
+        "    )\n",
+        ")\n",
+        "\n",
+        "lora_base_model_loaded = (\n",
+        "    lora_data.get(\n",
+        "        \"lora_base_model\",\n",
+        "        \"flux3_klein\"\n",
+        "    )\n",
+        ")\n",
+        "\n",
+        "lora_repo_id_loaded = (\n",
+        "    lora_data.get(\n",
+        "        \"repo_id\",\n",
+        "        \"\"\n",
+        "    )\n",
+        ")\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Image size\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "target_height = 1024\n",
+        "target_width = 1024\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Dataset files\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "encrypted_input_dataset_path = (\n",
+        "    dataset_path /\n",
+        "    \"foregrounds.zip\"\n",
+        ")\n",
+        "\n",
+        "backgrounds_input_dataset_path = (\n",
+        "    dataset_path /\n",
+        "    \"backgrounds.zip\"\n",
+        ")\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Runtime dtype\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "DTYPE = torch.float16\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Print\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "print()\n",
+        "print(\"=\" * 70)\n",
+        "print(\"CONFIG\")\n",
+        "print(\"=\" * 70)\n",
+        "\n",
+        "print(\"Model       :\", MODEL_ID)\n",
+        "print(\"Resolution  :\", resolution)\n",
+        "print(\"Dtype       :\", DTYPE)\n",
+        "print(\"Foregrounds :\", encrypted_input_dataset_path)\n",
+        "print(\"Backgrounds :\", backgrounds_input_dataset_path)\n",
+        "\n",
+        "print(\n",
+        "    f\"LoRA        : \"\n",
+        "    f\"{lora_name_loaded} @ {lora_strength_loaded}\"\n",
+        ")\n",
+        "\n",
+        "print(\"=\" * 70)\n",
+        "\n",
+        "gc.collect()\n",
+        "torch.cuda.empty_cache()"
+      ],
+      "metadata": {
+        "id": "lRI6tGZN07B5"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# =============================================================================\n",
+        "# CELL 5: FORCE SDNQ PYTORCH FALLBACK AND RETEST PUP\n",
+        "# =============================================================================\n",
+        "\n",
+        "import os\n",
+        "import gc\n",
+        "import sys\n",
+        "import time\n",
+        "import math\n",
+        "import random\n",
+        "import warnings\n",
+        "import subprocess\n",
+        "import traceback\n",
+        "import re\n",
+        "import shutil\n",
+        "import importlib.util\n",
+        "import logging\n",
+        "from pathlib import Path\n",
+        "from collections import Counter\n",
+        "from huggingface_hub import login, HfApi , hf_hub_download\n",
+        "def free():\n",
+        "    gc.collect()\n",
+        "    torch.cuda.empty_cache()\n",
+        "#---#\n",
+        "free()\n",
+        "\n",
+        "import gc\n",
+        "import inspect\n",
+        "import traceback\n",
+        "import torch\n",
+        "\n",
+        "import sdnq.kernel_wrappers as kw\n",
+        "import sdnq.layers.linear.linear_int8 as linear_int8\n",
+        "\n",
+        "print(\"=\" * 70)\n",
+        "print(\"SDNQ FALLBACK TEST\")\n",
+        "print(\"=\" * 70)\n",
+        "\n",
+        "print(\"Triton path before:\", kw.sdnq_scaled_mm)\n",
+        "print(\"PyTorch fallback  :\", getattr(linear_int8, \"int_scaled_mm_torch\", None))\n",
+        "\n",
+        "import os\n",
+        "import torch\n",
+        "import sdnq\n",
+        "import sdnq.kernel_wrappers as kw\n",
+        "\n",
+        "print(\"SDNQ_USE_TORCH_COMPILE:\",\n",
+        "      os.environ.get(\"SDNQ_USE_TORCH_COMPILE\"))\n",
+        "\n",
+        "print(\"Torch:\",\n",
+        "      torch.__version__)\n",
+        "\n",
+        "print(\"CUDA:\",\n",
+        "      torch.version.cuda)\n",
+        "\n",
+        "print(\"SDNQ scaled_mm:\",\n",
+        "      kw.sdnq_scaled_mm)\n",
+        "\n",
+        "\n",
+        "# -------------------------------------------------------------------------\n",
+        "# Reload PUP\n",
+        "# -------------------------------------------------------------------------\n",
+        "\n",
+        "from transformers import AutoProcessor, AutoModelForCausalLM\n",
+        "\n",
+        "PUP_REPO = MODEL_ID\n",
+        "PUP_SUBFOLDER = \"prompt_upsampler\"\n",
+        "OFFICIAL_PUP = \"black-forest-labs/flux-3-image-klein-pup\"\n",
+        "\n",
+        "print(\"📥 Loading processor...\")\n",
+        "\n",
+        "processor = AutoProcessor.from_pretrained(\n",
+        "    OFFICIAL_PUP,\n",
+        "    trust_remote_code=True,\n",
+        ")\n",
+        "\n",
+        "print(\"📥 Loading PUP...\")\n",
+        "\n",
+        "upsampler = AutoModelForCausalLM.from_pretrained(\n",
+        "    PUP_REPO,\n",
+        "    subfolder=PUP_SUBFOLDER,\n",
+        "    dtype=torch.float16,\n",
+        "    device_map=\"cuda\",\n",
+        "    trust_remote_code=True,\n",
+        "    low_cpu_mem_usage=True,\n",
+        ").eval()\n",
+        "\n",
+        "print(\"✅ PUP loaded\")\n",
+        "print()\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "KAgYgbkvFHLs"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ---------------------------------------------------------------------\n",
+        "# System prompts\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "try:\n",
+        "\n",
+        "    system_prompts_path = hf_hub_download(\n",
+        "        OFFICIAL_PUP,\n",
+        "        \"system_prompts.json\"\n",
+        "    )\n",
+        "\n",
+        "    with open(\n",
+        "        system_prompts_path,\n",
+        "        \"r\",\n",
+        "        encoding=\"utf-8\"\n",
+        "    ) as f:\n",
+        "\n",
+        "        system_prompts = json.load(f)\n",
+        "\n",
+        "    print(\"✅ Loaded official system prompts\")\n",
+        "\n",
+        "except Exception as e:\n",
+        "\n",
+        "    print(\n",
+        "        f\"⚠️ Could not load official \"\n",
+        "        f\"system_prompts.json: {e}\"\n",
+        "    )\n",
+        "\n",
+        "    system_prompts = {\n",
+        "        \"t2i\": (\n",
+        "            \"Expand the short prompt into a detailed \"\n",
+        "            \"photographic scene caption including subject, \"\n",
+        "            \"background, lighting, camera, materials and composition.\"\n",
+        "        ),\n",
+        "\n",
+        "        \"i2i\": (\n",
+        "            \"Expand the edit instruction into a detailed \"\n",
+        "            \"scene caption that incorporates the reference images.\"\n",
+        "        )\n",
+        "    }\n",
+        "\n",
+        "\n",
+        "# -------------------------------------------------------------------------\n",
+        "# Minimal generation test\n",
+        "# -------------------------------------------------------------------------\n",
+        "\n",
+        "messages = [\n",
+        "    {\n",
+        "        \"role\": \"system\",\n",
+        "        \"content\": system_prompts[\"t2i\"],\n",
+        "    },\n",
+        "    {\n",
+        "        \"role\": \"user\",\n",
+        "        \"content\": edit_prompt,\n",
+        "    },\n",
+        "]\n",
+        "\n",
+        "inputs = processor.apply_chat_template(\n",
+        "    messages,\n",
+        "    add_generation_prompt=True,\n",
+        "    tokenize=True,\n",
+        "    return_dict=True,\n",
+        "    return_tensors=\"pt\",\n",
+        "    enable_thinking=False,\n",
+        ")\n",
+        "\n",
+        "allowed_keys = {\n",
+        "    \"input_ids\",\n",
+        "    \"attention_mask\",\n",
+        "}\n",
+        "\n",
+        "filtered_inputs = {\n",
+        "    k: v.to(upsampler.device)\n",
+        "    for k, v in inputs.items()\n",
+        "    if k in allowed_keys\n",
+        "}\n",
+        "\n",
+        "print(\"Input:\", {\n",
+        "    k: tuple(v.shape)\n",
+        "    for k, v in filtered_inputs.items()\n",
+        "})\n",
+        "\n",
+        "# -------------------------------------------------------------------------\n",
+        "# Generate\n",
+        "# -------------------------------------------------------------------------\n",
+        "\n",
+        "print()\n",
+        "print(\"🧪 Testing generation with PyTorch fallback...\")\n",
+        "print()\n",
+        "\n",
+        "try:\n",
+        "\n",
+        "    with torch.inference_mode():\n",
+        "\n",
+        "        output = upsampler.generate(\n",
+        "            **filtered_inputs,\n",
+        "            max_new_tokens=256,\n",
+        "            do_sample=False,\n",
+        "            use_cache=True,\n",
+        "        )\n",
+        "\n",
+        "    prompt_length = filtered_inputs[\"input_ids\"].shape[1]\n",
+        "\n",
+        "    caption = processor.decode(\n",
+        "        output[0, prompt_length:],\n",
+        "        skip_special_tokens=True,\n",
+        "    ).strip()\n",
+        "\n",
+        "    print(\"=\" * 70)\n",
+        "    print(\"🎉 FALLBACK TEST SUCCEEDED\")\n",
+        "    print(\"=\" * 70)\n",
+        "    print()\n",
+        "    print(caption)\n",
+        "\n",
+        "except Exception as e:\n",
+        "\n",
+        "    print(\"=\" * 70)\n",
+        "    print(\"❌ FALLBACK TEST FAILED\")\n",
+        "    print(\"=\" * 70)\n",
+        "\n",
+        "    print()\n",
+        "    print(\"Error type:\", type(e).__name__)\n",
+        "    print(\"Error:\", e)\n",
+        "\n",
+        "    traceback.print_exc()\n",
+        "\n",
+        "finally:\n",
+        "\n",
+        "    try:\n",
+        "        del upsampler\n",
+        "    except:\n",
+        "        pass\n",
+        "\n",
+        "    try:\n",
+        "        del processor\n",
+        "    except:\n",
+        "        pass\n",
+        "\n",
+        "    gc.collect()\n",
+        "    torch.cuda.empty_cache()"
+      ],
+      "metadata": {
+        "id": "A20k274KKEzZ"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "#orwpjgwop"
+      ],
+      "metadata": {
+        "id": "w6OVCivCI4ha"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# =============================================================================\n",
+        "# CELL 4: PROMPT UPSAMPLER\n",
+        "# FLUX 3 KLEIN SDNQ\n",
+        "# =============================================================================\n",
+        "\n",
+        "import gc\n",
+        "import json\n",
+        "import traceback\n",
+        "import torch\n",
+        "\n",
+        "from transformers import (\n",
+        "    AutoProcessor,\n",
+        "    AutoModelForCausalLM,\n",
+        ")\n",
+        "\n",
+        "from huggingface_hub import hf_hub_download\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Reclaim VRAM\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "gc.collect()\n",
+        "torch.cuda.empty_cache()\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Repositories\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "PUP_REPO = MODEL_ID\n",
+        "\n",
+        "PUP_SUBFOLDER = \"prompt_upsampler\"\n",
+        "\n",
+        "OFFICIAL_PUP = (\n",
+        "    \"black-forest-labs/\"\n",
+        "    \"flux-3-image-klein-pup\"\n",
+        ")\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# System prompts\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "try:\n",
+        "\n",
+        "    system_prompts_path = hf_hub_download(\n",
+        "        OFFICIAL_PUP,\n",
+        "        \"system_prompts.json\"\n",
+        "    )\n",
+        "\n",
+        "    with open(\n",
+        "        system_prompts_path,\n",
+        "        \"r\",\n",
+        "        encoding=\"utf-8\"\n",
+        "    ) as f:\n",
+        "\n",
+        "        system_prompts = json.load(f)\n",
+        "\n",
+        "    print(\"✅ Loaded official system prompts\")\n",
+        "\n",
+        "except Exception as e:\n",
+        "\n",
+        "    print(\n",
+        "        f\"⚠️ Could not load official \"\n",
+        "        f\"system_prompts.json: {e}\"\n",
+        "    )\n",
+        "\n",
+        "    system_prompts = {\n",
+        "        \"t2i\": (\n",
+        "            \"Expand the short prompt into a detailed \"\n",
+        "            \"photographic scene caption including subject, \"\n",
+        "            \"background, lighting, camera, materials and composition.\"\n",
+        "        ),\n",
+        "\n",
+        "        \"i2i\": (\n",
+        "            \"Expand the edit instruction into a detailed \"\n",
+        "            \"scene caption that incorporates the reference images.\"\n",
+        "        )\n",
+        "    }\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Processor\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "print(\"\\n📥 Loading official PUP processor...\")\n",
+        "\n",
+        "processor = AutoProcessor.from_pretrained(\n",
+        "    OFFICIAL_PUP,\n",
+        "    trust_remote_code=True\n",
+        ")\n",
+        "\n",
+        "print(\"✅ Processor loaded\")\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Quantized PUP model\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "print(\"\\n📥 Loading SDNQ prompt upsampler...\")\n",
+        "print(\"   Runtime dtype: FP16\")\n",
+        "print(\"   Device: CUDA\")\n",
+        "\n",
+        "upsampler = AutoModelForCausalLM.from_pretrained(\n",
+        "    PUP_REPO,\n",
+        "    subfolder=PUP_SUBFOLDER,\n",
+        "    dtype=torch.float16,\n",
+        "    device_map=\"cuda\",\n",
+        "    trust_remote_code=True,\n",
+        "    low_cpu_mem_usage=True,\n",
+        ").eval()\n",
+        "\n",
+        "print(\"✅ Prompt upsampler loaded\")\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Prompt function\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "def upsample_prompt(\n",
+        "    prompt: str,\n",
+        "    images=None\n",
+        "):\n",
+        "\n",
+        "    if images is None:\n",
+        "        images = []\n",
+        "\n",
+        "    if not isinstance(\n",
+        "        images,\n",
+        "        (list, tuple)\n",
+        "    ):\n",
+        "        images = [images]\n",
+        "\n",
+        "    # -------------------------------------------------------------\n",
+        "    # Messages\n",
+        "    # -------------------------------------------------------------\n",
+        "\n",
+        "    if images:\n",
+        "\n",
+        "        text = (\n",
+        "            \"Reference images follow in order \"\n",
+        "            \"(the first image, the second image, ...).\\n\"\n",
+        "            f\"User request: {prompt}\\n\"\n",
+        "            \"Output the caption.\"\n",
+        "        )\n",
+        "\n",
+        "        content = (\n",
+        "            [\n",
+        "                {\n",
+        "                    \"type\": \"image\",\n",
+        "                    \"image\": img\n",
+        "                }\n",
+        "                for img in images\n",
+        "            ]\n",
+        "            +\n",
+        "            [\n",
+        "                {\n",
+        "                    \"type\": \"text\",\n",
+        "                    \"text\": text\n",
+        "                }\n",
+        "            ]\n",
+        "        )\n",
+        "\n",
+        "        messages = [\n",
+        "            {\n",
+        "                \"role\": \"system\",\n",
+        "                \"content\": system_prompts.get(\n",
+        "                    \"i2i\",\n",
+        "                    system_prompts[\"t2i\"]\n",
+        "                )\n",
+        "            },\n",
+        "            {\n",
+        "                \"role\": \"user\",\n",
+        "                \"content\": content\n",
+        "            }\n",
+        "        ]\n",
+        "\n",
+        "    else:\n",
+        "\n",
+        "        messages = [\n",
+        "            {\n",
+        "                \"role\": \"system\",\n",
+        "                \"content\": system_prompts[\"t2i\"]\n",
+        "            },\n",
+        "            {\n",
+        "                \"role\": \"user\",\n",
+        "                \"content\": prompt\n",
+        "            }\n",
+        "        ]\n",
+        "\n",
+        "    # -------------------------------------------------------------\n",
+        "    # Processor\n",
+        "    # -------------------------------------------------------------\n",
+        "\n",
+        "    inputs = processor.apply_chat_template(\n",
+        "        messages,\n",
+        "        add_generation_prompt=True,\n",
+        "        tokenize=True,\n",
+        "        return_dict=True,\n",
+        "        return_tensors=\"pt\",\n",
+        "        enable_thinking=False\n",
+        "    )\n",
+        "\n",
+        "    # -------------------------------------------------------------\n",
+        "    # Only pass model-supported text inputs\n",
+        "    # -------------------------------------------------------------\n",
+        "\n",
+        "    allowed_keys = {\n",
+        "        \"input_ids\",\n",
+        "        \"attention_mask\"\n",
+        "    }\n",
+        "\n",
+        "    if \"token_type_ids\" in inputs:\n",
+        "        allowed_keys.add(\n",
+        "            \"token_type_ids\"\n",
+        "        )\n",
+        "\n",
+        "    filtered_inputs = {\n",
+        "        k: v.to(upsampler.device)\n",
+        "        if torch.is_tensor(v)\n",
+        "        else v\n",
+        "\n",
+        "        for k, v in inputs.items()\n",
+        "\n",
+        "        if k in allowed_keys\n",
+        "    }\n",
+        "\n",
+        "    print(\n",
+        "        \"\\n🧪 PUP input:\",\n",
+        "        {\n",
+        "            k: (\n",
+        "                tuple(v.shape)\n",
+        "                if torch.is_tensor(v)\n",
+        "                else type(v).__name__\n",
+        "            )\n",
+        "            for k, v in filtered_inputs.items()\n",
+        "        }\n",
+        "    )\n",
+        "\n",
+        "    # -------------------------------------------------------------\n",
+        "    # Generate\n",
+        "    # -------------------------------------------------------------\n",
+        "\n",
+        "    with torch.inference_mode():\n",
+        "\n",
+        "        output = upsampler.generate(\n",
+        "            **filtered_inputs,\n",
+        "            max_new_tokens=1536,\n",
+        "            do_sample=False,\n",
+        "            use_cache=True\n",
+        "        )\n",
+        "\n",
+        "    # -------------------------------------------------------------\n",
+        "    # Decode\n",
+        "    # -------------------------------------------------------------\n",
+        "\n",
+        "    prompt_length = (\n",
+        "        filtered_inputs[\n",
+        "            \"input_ids\"\n",
+        "        ].shape[1]\n",
+        "    )\n",
+        "\n",
+        "    caption = processor.decode(\n",
+        "        output[\n",
+        "            0,\n",
+        "            prompt_length:\n",
+        "        ],\n",
+        "        skip_special_tokens=True\n",
+        "    ).strip()\n",
+        "\n",
+        "    return caption\n",
+        "\n",
+        "# =============================================================================\n",
+        "# GENERATE CAPTION\n",
+        "# =============================================================================\n",
+        "\n",
+        "FULL_CAPTION = None\n",
+        "PUP_ERROR = None\n",
+        "\n",
+        "print(\"\\n🧠 Generating expanded prompt...\")\n",
+        "print(\"   This is the point where the SDNQ/Triton issue\")\n",
+        "print(\"   previously occurred.\\n\")\n",
+        "\n",
+        "try:\n",
+        "\n",
+        "    FULL_CAPTION = upsample_prompt(\n",
+        "        edit_prompt\n",
+        "    )\n",
+        "\n",
+        "    print(\"\\n\" + \"=\" * 70)\n",
+        "    print(\"✅ PROMPT UPSAMPLER SUCCESS\")\n",
+        "    print(\"=\" * 70)\n",
+        "\n",
+        "    print(\n",
+        "        f\"\\nCaption length: \"\n",
+        "        f\"{len(FULL_CAPTION)} characters\\n\"\n",
+        "    )\n",
+        "\n",
+        "    print(FULL_CAPTION)\n",
+        "\n",
+        "except Exception as e:\n",
+        "\n",
+        "    PUP_ERROR = e\n",
+        "\n",
+        "    print(\"\\n\" + \"=\" * 70)\n",
+        "    print(\"❌ PROMPT UPSAMPLER FAILED\")\n",
+        "    print(\"=\" * 70)\n",
+        "\n",
+        "    print(\n",
+        "        \"\\nThis is expected to reach the diagnostic \"\n",
+        "        \"cell below if the SDNQ Triton kernel is still broken.\\n\"\n",
+        "    )\n",
+        "\n",
+        "    print(\n",
+        "        f\"Error type: {type(e).__name__}\"\n",
+        "    )\n",
+        "\n",
+        "    print(\n",
+        "        f\"Error: {e}\"\n",
+        "    )\n",
+        "\n",
+        "    traceback.print_exc()\n",
+        "\n",
+        "# ---------------------------------------------------------------------\n",
+        "# Free PUP\n",
+        "# ---------------------------------------------------------------------\n",
+        "\n",
+        "print(\"\\n🧹 Freeing prompt upsampler...\")\n",
+        "\n",
+        "try:\n",
+        "    del upsampler\n",
+        "except:\n",
+        "    pass\n",
+        "\n",
+        "try:\n",
+        "    del processor\n",
+        "except:\n",
+        "    pass\n",
+        "\n",
+        "gc.collect()\n",
+        "torch.cuda.empty_cache()\n",
+        "\n",
+        "print(\"✅ PUP memory released\")\n",
+        "\n",
+        "if FULL_CAPTION is None:\n",
+        "    print(\n",
+        "        \"\\n⚠️ FULL_CAPTION is None.\"\n",
+        "        \"\\nThe final diagnostic cell will now determine \"\n",
+        "        \"whether SDNQ's Triton INT8 matmul is the problem.\"\n",
+        "    )"
+      ],
+      "metadata": {
+        "id": "u6Pt0R69_Hv-"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# CONT"
+      ],
+      "metadata": {
+        "id": "VkzXQxOK-ooR"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# =============================================================================\n",
+        "# CELL 4: Parallel Workers\n",
+        "# =============================================================================\n",
+        "\n",
+        "import io, gc, zipfile, hashlib, traceback, random as pyrandom, shutil, time\n",
+        "from PIL import Image\n",
+        "from nacl.secret import SecretBox\n",
+        "from concurrent.futures import ThreadPoolExecutor, as_completed\n",
+        "from pathlib import Path\n",
+        "\n",
+        "output_folders = [f\"/content/edited_gpu{gpu}_pipe{p}\" for gpu in range(NUM_GPUS) for p in range(PIPES_PER_GPU)]\n",
+        "final_output_folder = \"/content/final_encrypted\"\n",
+        "for folder in output_folders + [final_output_folder]:\n",
+        "    os.makedirs(folder, exist_ok=True)\n",
+        "\n",
+        "password = (Path(google_drive_dataset_path) / \"password.txt\").read_text(encoding=\"utf-8\").strip()\n",
+        "key = hashlib.sha256(password.encode()).digest()\n",
+        "box = SecretBox(key)\n",
+        "\n",
+        "foreground_zip = zipfile.ZipFile(encrypted_input_dataset_path, \"r\")\n",
+        "background_zip = zipfile.ZipFile(backgrounds_input_dataset_path, \"r\")\n",
+        "\n",
+        "input_files = sorted([x for x in foreground_zip.namelist() if x.endswith(\"_encrypted.bin\")])\n",
+        "bg_files = sorted([x for x in background_zip.namelist() if x.endswith(\"_encrypted.bin\")])\n",
+        "\n",
+        "print(f\"📊 Found {len(input_files)} foregrounds | {len(bg_files)} backgrounds\")\n",
+        "\n",
+        "def worker_thread(pipe, gpu_id, start_idx, num_images, worker_id):\n",
+        "    torch.cuda.set_device(gpu_id)\n",
+        "    torch._dynamo.reset()\n",
+        "    torch._dynamo.config.suppress_errors = True\n",
+        "    torch._dynamo.config.disable = True\n",
+        "    os.environ[\"TORCHDYNAMO_DISABLE\"] = \"1\"\n",
+        "\n",
+        "    def decrypt(data):\n",
+        "        return box.decrypt(data)\n",
+        "\n",
+        "    def encrypt(data):\n",
+        "        return box.encrypt(data)\n",
+        "\n",
+        "    def bytes_to_pil(b):\n",
+        "        return Image.open(io.BytesIO(b)).convert(\"RGB\")\n",
+        "\n",
+        "    def pil_to_bytes(img):\n",
+        "        buf = io.BytesIO()\n",
+        "        img.save(buf, format=\"JPEG\", quality=90)\n",
+        "        return buf.getvalue()\n",
+        "\n",
+        "    def resize_max_side(pil_image: Image.Image, max_size: int = 1024) -> Image.Image:\n",
+        "        if max(pil_image.size) <= max_size:\n",
+        "            return pil_image\n",
+        "        w, h = pil_image.size\n",
+        "        if w > h:\n",
+        "            new_w = max_size\n",
+        "            new_h = int(h * (max_size / w))\n",
+        "        else:\n",
+        "            new_h = max_size\n",
+        "            new_w = int(w * (max_size / h))\n",
+        "        return pil_image.resize((new_w, new_h), Image.LANCZOS)\n",
+        "\n",
+        "    for i in range(num_images):\n",
+        "        global_idx = start_idx + i\n",
+        "        if global_idx >= len(input_files):\n",
+        "            break\n",
+        "\n",
+        "        try:\n",
+        "            gc.collect()\n",
+        "            torch.cuda.empty_cache()\n",
+        "\n",
+        "            # Foreground\n",
+        "            fg_name = input_files[global_idx]\n",
+        "            with foreground_zip.open(fg_name) as f:\n",
+        "                decrypted_fg = decrypt(f.read())\n",
+        "            input_image = bytes_to_pil(decrypted_fg)\n",
+        "            input_image = resize_max_side(input_image, 1024)\n",
+        "\n",
+        "            # Background (random)\n",
+        "            bg_name = pyrandom.choice(bg_files)\n",
+        "            with background_zip.open(bg_name) as f:\n",
+        "                decrypted_bg = decrypt(f.read())\n",
+        "            bg_image = bytes_to_pil(decrypted_bg)\n",
+        "            bg_image = resize_max_side(bg_image, 1024)\n",
+        "\n",
+        "            # ---- Prompt Upsampling (critical for Flux 3) ----\n",
+        "            full_caption = upsample_prompt(edit_prompt, images=[input_image, bg_image])\n",
+        "            # print(f\"Caption preview: {full_caption[:120]}...\")\n",
+        "\n",
+        "            # ---- Inference ----\n",
+        "            with torch.inference_mode(), torch.no_grad():\n",
+        "                result = pipe(\n",
+        "                    prompt=full_caption,\n",
+        "                    image=[input_image, bg_image],   # multi-reference\n",
+        "                    height=target_height,\n",
+        "                    width=target_width,\n",
+        "                    num_inference_steps=16,          # distilled default\n",
+        "                    guidance_scale=1.0,\n",
+        "                    generator=torch.Generator(f\"cuda:{gpu_id}\").manual_seed(42 + global_idx),\n",
+        "                    output=\"images\",\n",
+        "                )[0]\n",
+        "\n",
+        "            # Encrypt & save\n",
+        "            encrypted_result = encrypt(pil_to_bytes(result))\n",
+        "            out_path = os.path.join(output_folders[worker_id], f\"edited_{global_idx:06d}.enc\")\n",
+        "            with open(out_path, \"wb\") as f:\n",
+        "                f.write(encrypted_result)\n",
+        "\n",
+        "            print(f\"✅ Worker {worker_id} (GPU {gpu_id}) → {global_idx+1}/{len(input_files)}\")\n",
+        "\n",
+        "            del result, input_image, bg_image, decrypted_fg, decrypted_bg, encrypted_result, full_caption\n",
+        "\n",
+        "        except Exception as e:\n",
+        "            print(f\"❌ Worker {worker_id} failed at {global_idx}: {e}\")\n",
+        "            traceback.print_exc()\n",
+        "\n",
+        "        gc.collect()\n",
+        "\n",
+        "    return True\n",
+        "\n",
+        "\n",
+        "print(\"\\n🚀 Starting parallel workers...\")\n",
+        "\n",
+        "chunk_size = (len(input_files) + len(pipes) - 1) // len(pipes)\n",
+        "\n",
+        "futures = []\n",
+        "with ThreadPoolExecutor(max_workers=len(pipes)) as executor:\n",
+        "    for w in range(len(pipes)):\n",
+        "        start_idx = w * chunk_size\n",
+        "        num_images = min(chunk_size, len(input_files) - start_idx)\n",
+        "        if num_images <= 0:\n",
+        "            continue\n",
+        "        if w > 0:\n",
+        "            time.sleep(1.5)\n",
+        "\n",
+        "        future = executor.submit(\n",
+        "            worker_thread,\n",
+        "            pipes[w],\n",
+        "            gpu_ids_list[w],\n",
+        "            start_idx,\n",
+        "            num_images,\n",
+        "            w\n",
+        "        )\n",
+        "        futures.append(future)\n",
+        "\n",
+        "    for future in as_completed(futures):\n",
+        "        try:\n",
+        "            future.result()\n",
+        "        except Exception as e:\n",
+        "            print(f\"Worker failed with: {e}\")\n",
+        "\n",
+        "print(\"\\n🎉 All workers completed!\")\n",
+        "\n",
+        "foreground_zip.close()\n",
+        "background_zip.close()\n",
+        "gc.collect()"
+      ],
+      "metadata": {
+        "id": "AzTKRdQE1Acx"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# =============================================================================\n",
+        "# CELL 5: Combine into Final ZIP\n",
+        "# =============================================================================\n",
+        "\n",
+        "import shutil\n",
+        "from pathlib import Path\n",
+        "\n",
+        "print(\"📦 Creating final zip...\")\n",
+        "\n",
+        "for folder in output_folders:\n",
+        "    if os.path.exists(folder):\n",
+        "        for f in Path(folder).glob(\"*.enc\"):\n",
+        "            shutil.copy2(f, os.path.join(final_output_folder, f.name))\n",
+        "\n",
+        "collected = len(list(Path(final_output_folder).glob(\"*.enc\")))\n",
+        "print(f\"Collected {collected} encrypted files\")\n",
+        "\n",
+        "final_zip_base = \"/content/final_encrypted_outputs\"\n",
+        "shutil.make_archive(final_zip_base, 'zip', final_output_folder)\n",
+        "\n",
+        "print(f\"\\n✅ SUCCESS! Final file: {final_zip_base}.zip\")\n",
+        "print(\"You can download it from the file browser.\")"
+      ],
+      "metadata": {
+        "id": "mTxspyuT1DrZ"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "RfFDaKSg1EUd"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import shutil\n",
+        "import io\n",
+        "import hashlib\n",
+        "from pathlib import Path\n",
+        "from PIL import Image\n",
+        "!pip install pynacl\n",
+        "from nacl.secret import SecretBox\n",
+        "from google.colab import files\n",
+        "import zipfile\n",
+        "from google.colab import drive\n",
+        "#@markdown 🔑 Decrypt Results (either by widget uploading zip or by manual filepath to saved zip on drive)\n",
+        "print(\"🔓 Decryption Notebook Ready\")\n",
+        "\n",
+        "# ------------------- INPUTS -------------------\n",
+        "password = 'banana' # @param {type:\"string\"}\n",
+        "use_manual_filepath = True  # @param {type:\"boolean\"}\n",
+        "manual_filepath = '/content/final_encrypted_outputs.zip' # @param {type:\"string\"}\n",
+        "\n",
+        "# ------------------- FILE INPUT LOGIC -------------------\n",
+        "zip_filename = None\n",
+        "\n",
+        "if use_manual_filepath:\n",
+        "    if not os.path.exists('/content/drive'):\n",
+        "        print(\"🔄 Mounting Google Drive...\")\n",
+        "        drive.mount('/content/drive')\n",
+        "\n",
+        "    if not manual_filepath:\n",
+        "        raise ValueError(\"❌ Manual filepath cannot be empty when 'Use manual filepath' is enabled!\")\n",
+        "\n",
+        "    if not os.path.exists(manual_filepath):\n",
+        "        raise FileNotFoundError(f\"❌ File not found at manual filepath: {manual_filepath}\")\n",
+        "\n",
+        "    zip_filename = manual_filepath\n",
+        "    print(f\"✅ Using manual filepath: {zip_filename}\")\n",
+        "else:\n",
+        "    print(\"\\n📤 Upload your final_encrypted_outputs.zip file:\")\n",
+        "    uploaded = files.upload()\n",
+        "\n",
+        "    for fn in uploaded.keys():\n",
+        "        if fn.endswith('.zip'):\n",
+        "            zip_filename = fn\n",
+        "            break\n",
+        "\n",
+        "    if not zip_filename:\n",
+        "        raise ValueError(\"❌ No .zip file was uploaded!\")\n",
+        "\n",
+        "    print(f\"✅ Uploaded: {zip_filename}\")\n",
+        "\n",
+        "# ------------------- DECRYPTION FUNCTION -------------------\n",
+        "def decrypt_data(encrypted_data: bytes, box: SecretBox) -> bytes:\n",
+        "    try:\n",
+        "        return box.decrypt(encrypted_data)\n",
+        "    except Exception as e:\n",
+        "        raise ValueError(f\"Decryption failed (wrong password?): {e})\")\n",
+        "\n",
+        "# ------------------- MAIN DECRYPTION -------------------\n",
+        "\n",
+        "if not password:\n",
+        "    raise ValueError(\"❌ Password cannot be empty!\")\n",
+        "\n",
+        "# Derive the same key as in the encryption code\n",
+        "key = hashlib.sha256(password.encode('utf-8')).digest()\n",
+        "box = SecretBox(key)\n",
+        "\n",
+        "# Create output folder\n",
+        "output_dir = \"/content/decrypted_images\"\n",
+        "os.makedirs(output_dir, exist_ok=True)\n",
+        "\n",
+        "print(f\"\\n📂 Extracting and decrypting to: {output_dir}\")\n",
+        "\n",
+        "# Extract zip\n",
+        "with zipfile.ZipFile(zip_filename, 'r') as zip_ref:\n",
+        "    zip_ref.extractall(\"/content/temp_extracted\")\n",
+        "\n",
+        "# Find all .enc files\n",
+        "enc_files = list(Path(\"/content/temp_extracted\").rglob(\"*.enc\"))\n",
+        "\n",
+        "print(f\"🔍 Found {len(enc_files)} encrypted files\")\n",
+        "\n",
+        "success_count = 0\n",
+        "\n",
+        "for enc_path in enc_files:\n",
+        "    try:\n",
+        "        with open(enc_path, \"rb\") as f:\n",
+        "            encrypted_bytes = f.read()\n",
+        "\n",
+        "        # Decrypt\n",
+        "        decrypted_bytes = decrypt_data(encrypted_bytes, box)\n",
+        "\n",
+        "        # Convert to PIL Image and save as JPG\n",
+        "        img = Image.open(io.BytesIO(decrypted_bytes)).convert(\"RGB\")\n",
+        "\n",
+        "        output_path = os.path.join(output_dir, enc_path.stem + \".jpg\")\n",
+        "        img.save(output_path, format=\"JPEG\", quality=95)\n",
+        "\n",
+        "        success_count += 1\n",
+        "        print(f\"✅ Decrypted: {enc_path.name} → {Path(output_path).name}\")\n",
+        "\n",
+        "    except Exception as e:\n",
+        "        print(f\"❌ Failed {enc_path.name}: {e}\")\n",
+        "\n",
+        "# Cleanup temp folder\n",
+        "shutil.rmtree(\"/content/temp_extracted\", ignore_errors=True)\n",
+        "\n",
+        "print(f\"\\n🎉 Decryption complete! {success_count}/{len(enc_files)} files decrypted successfully.\")\n",
+        "print(f\"📁 Decrypted images saved to: {output_dir}\")\n",
+        "\n",
+        "# Optional: Download all decrypted images as a new zip\n",
+        "download_zip = True #input(\"\\nDo you want to download all decrypted images as a zip? (y/n): \").lower().strip() == 'y'\n",
+        "\n",
+        "if download_zip:\n",
+        "    download_zip_path = \"/content/decrypted_images.zip\"\n",
+        "    shutil.make_archive(\"/content/decrypted_images\", 'zip', output_dir)\n",
+        "    files.download(download_zip_path)\n",
+        "    print(\"📥 Download started...\")"
+      ],
+      "metadata": {
+        "id": "GvLYqh4iMBf_"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# CREATE SDNQ (For reference)"
+      ],
+      "metadata": {
+        "id": "95PI6Rr74piE"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# CREATEW SDNQ - only kept for reference\n",
+        "if False:\n",
+        "        #@title CELL 1 — Install + HF Login\n",
+        "        !pip install -q --upgrade huggingface_hub transformers accelerate safetensors\n",
+        "        !pip install -q git+https://github.com/huggingface/diffusers.git\n",
+        "        !pip install -q sdnq\n",
+        "\n",
+        "        import os\n",
+        "        import gc\n",
+        "        import sys\n",
+        "        import time\n",
+        "        import math\n",
+        "        import random\n",
+        "        import warnings\n",
+        "        import subprocess\n",
+        "        import traceback\n",
+        "        import re\n",
+        "        import shutil\n",
+        "        import importlib.util\n",
+        "        import logging\n",
+        "        from pathlib import Path\n",
+        "        from collections import Counter\n",
+        "        from huggingface_hub import login, HfApi\n",
+        "\n",
+        "\n",
+        "        import os\n",
+        "        # Put your token in Kaggle Secrets as \"HF_TOKEN\"\n",
+        "        from kaggle_secrets import UserSecretsClient\n",
+        "        user_secrets = UserSecretsClient()\n",
+        "        DATASET_DIR = Path(\n",
+        "            \"/kaggle/input/datasets/nekos4lyfe/image-caption-dataset\"\n",
+        "        )\n",
+        "        hf_token_path = DATASET_DIR / \"HF_TOKEN.txt\"\n",
+        "\n",
+        "        if hf_token_path.exists():\n",
+        "\n",
+        "            hf_token = hf_token_path.read_text(\n",
+        "                encoding=\"utf-8\"\n",
+        "            ).strip()\n",
+        "        login(token=hf_token)\n",
+        "\n",
+        "        print(\"✅ Environment ready\")\n",
+        "\n",
+        "        #@title CELL 2 — Load full transformer on CPU\n",
+        "        import torch, gc, os\n",
+        "        from diffusers import Flux3Transformer2DModel\n",
+        "\n",
+        "        gc.collect()\n",
+        "        torch.cuda.empty_cache()\n",
+        "\n",
+        "        print(\"Loading Flux3Transformer2DModel on CPU (low_cpu_mem_usage)...\")\n",
+        "        transformer = Flux3Transformer2DModel.from_pretrained(\n",
+        "            \"black-forest-labs/flux-3-image-klein\",\n",
+        "            subfolder=\"transformer\",\n",
+        "            torch_dtype=torch.float16,\n",
+        "            low_cpu_mem_usage=True,\n",
+        "            device_map=\"cpu\",\n",
+        "            token=hf_token,\n",
+        "        )\n",
+        "\n",
+        "        print(\"✅ Transformer loaded on CPU\")\n",
+        "        print(f\"Total parameters: {sum(p.numel() for p in transformer.parameters()) / 1e9:.2f} B\")\n",
+        "\n",
+        "        #@title CELL 3 — Sequential SDNQ quantization (fixed)\n",
+        "        from sdnq import sdnq_post_load_quant\n",
+        "        import torch, gc\n",
+        "        from torch import nn\n",
+        "\n",
+        "        def free():\n",
+        "            gc.collect()\n",
+        "            torch.cuda.empty_cache()\n",
+        "\n",
+        "        # -------------------------------------------------\n",
+        "        # Same SDNQ config\n",
+        "        # -------------------------------------------------\n",
+        "        SDNQ_KWARGS = dict(\n",
+        "            weights_dtype=\"int4\",\n",
+        "            group_size=0,\n",
+        "            use_svd=False,\n",
+        "            quant_conv=False,\n",
+        "            quant_embedding=False,\n",
+        "            use_quantized_matmul=True,\n",
+        "            dequantize_fp32=True,\n",
+        "            non_blocking=False,\n",
+        "            add_skip_keys=True,\n",
+        "            quantization_device=\"cuda\",\n",
+        "            return_device=\"cpu\",\n",
+        "            modules_to_not_convert=[\n",
+        "                \"x_embedder\", \"context_embedder\", \"pos_embed\", \"norm_out\",\n",
+        "                \".proj_out\", \"time_guidance_embed\", \"final_layer\",\n",
+        "                \"double_stream_modulation_img\", \"double_stream_modulation_txt\",\n",
+        "                \"single_stream_modulation\",\n",
+        "                \"target_timestep_embedder\",\n",
+        "            ],\n",
+        "        )\n",
+        "\n",
+        "        # -------------------------------------------------\n",
+        "        # Robustly collect every major block (ModuleList or ModuleDict)\n",
+        "        # -------------------------------------------------\n",
+        "        blocks = []   # list of (full_name, module)\n",
+        "\n",
+        "        def collect_blocks(root, prefix=\"\"):\n",
+        "            \"\"\"Recursively find ModuleLists / ModuleDicts that contain transformer blocks.\"\"\"\n",
+        "            for name, child in root.named_children():\n",
+        "                full_name = f\"{prefix}.{name}\" if prefix else name\n",
+        "\n",
+        "                # Case 1: ModuleList of blocks\n",
+        "                if isinstance(child, nn.ModuleList):\n",
+        "                    for i, blk in enumerate(child):\n",
+        "                        if isinstance(blk, nn.Module):\n",
+        "                            blocks.append((f\"{full_name}.{i}\", blk))\n",
+        "                    continue\n",
+        "\n",
+        "                # Case 2: ModuleDict of blocks (or of ModuleLists)\n",
+        "                if isinstance(child, nn.ModuleDict):\n",
+        "                    for key, sub in child.items():\n",
+        "                        if isinstance(sub, nn.ModuleList):\n",
+        "                            for i, blk in enumerate(sub):\n",
+        "                                if isinstance(blk, nn.Module):\n",
+        "                                    blocks.append((f\"{full_name}.{key}.{i}\", blk))\n",
+        "                        elif isinstance(sub, nn.Module):\n",
+        "                            # single module under a key\n",
+        "                            blocks.append((f\"{full_name}.{key}\", sub))\n",
+        "                    continue\n",
+        "\n",
+        "                # Recurse deeper for nested structures\n",
+        "                collect_blocks(child, full_name)\n",
+        "\n",
+        "        # Run discovery\n",
+        "        collect_blocks(transformer)\n",
+        "\n",
+        "        print(f\"Found {len(blocks)} major blocks\")\n",
+        "        for n, _ in blocks[:5]:\n",
+        "            print(\"  \", n)\n",
+        "        if len(blocks) > 5:\n",
+        "            print(\"  ...\")\n",
+        "\n",
+        "        # Split into ~20 equal parts (or 1 block each if you prefer)\n",
+        "        N_PARTS = 20\n",
+        "        chunk_size = max(1, (len(blocks) + N_PARTS - 1) // N_PARTS)\n",
+        "        parts = [blocks[i:i + chunk_size] for i in range(0, len(blocks), chunk_size)]\n",
+        "        print(f\"Split into {len(parts)} parts (≈{chunk_size} blocks each)\")\n",
+        "\n",
+        "        # -------------------------------------------------\n",
+        "        # Quantize one part at a time\n",
+        "        # -------------------------------------------------\n",
+        "        num_gpus = torch.cuda.device_count()\n",
+        "        print(f\"Using {num_gpus} GPU(s)\")\n",
+        "\n",
+        "        for part_idx, part in enumerate(parts):\n",
+        "            device = f\"cuda:{part_idx % num_gpus}\"\n",
+        "            print(f\"\\n=== Part {part_idx+1}/{len(parts)} on {device} ===\")\n",
+        "\n",
+        "            # 1. Move blocks of this part to GPU\n",
+        "            for name, blk in part:\n",
+        "                blk.to(device)\n",
+        "            free()\n",
+        "\n",
+        "            # 2. Quantize each block\n",
+        "            for name, blk in part:\n",
+        "                print(f\"  Quantizing {name} ...\")\n",
+        "                quantized_blk = sdnq_post_load_quant(\n",
+        "                    blk,\n",
+        "                    **{**SDNQ_KWARGS, \"quantization_device\": device}\n",
+        "                )\n",
+        "\n",
+        "                # Put the quantized module back into the original model tree\n",
+        "                parent = transformer\n",
+        "                attrs = name.split(\".\")\n",
+        "                for a in attrs[:-1]:\n",
+        "                    parent = getattr(parent, a)\n",
+        "                setattr(parent, attrs[-1], quantized_blk.to(\"cpu\"))\n",
+        "\n",
+        "                del quantized_blk\n",
+        "                free()\n",
+        "\n",
+        "            # 3. Ensure everything is back on CPU\n",
+        "            for name, blk in part:\n",
+        "                # blk may already be replaced, so we re-fetch it\n",
+        "                parent = transformer\n",
+        "                attrs = name.split(\".\")\n",
+        "                for a in attrs[:-1]:\n",
+        "                    parent = getattr(parent, a)\n",
+        "                getattr(parent, attrs[-1]).to(\"cpu\")\n",
+        "            free()\n",
+        "\n",
+        "        print(\"\\n✅ All major blocks quantized successfully\")\n",
+        "\n",
+        "        #@title CELL 4 — Quantize remaining modules + Save\n",
+        "        print(\"Quantizing remaining (non-block) modules on cuda:0 ...\")\n",
+        "\n",
+        "        # Everything that is still on CPU and not yet quantized\n",
+        "        # will be handled by one final call on the whole model.\n",
+        "        # Because the heavy blocks are already quantized, this is cheap.\n",
+        "        transformer = sdnq_post_load_quant(\n",
+        "            transformer,\n",
+        "            **{**SDNQ_KWARGS, \"quantization_device\": \"cuda:0\"}\n",
+        "        )\n",
+        "\n",
+        "        free()\n",
+        "\n",
+        "        save_dir = \"/kaggle/working/flux3-klein-sdnq-int4/transformer\"\n",
+        "        os.makedirs(save_dir, exist_ok=True)\n",
+        "\n",
+        "        print(\"Saving quantized transformer (this writes the merged safetensors)...\")\n",
+        "        transformer.save_pretrained(save_dir, safe_serialization=True)\n",
+        "        print(f\"✅ Saved to {save_dir}\")\n",
+        "\n",
+        "        # Optional: show the files\n",
+        "        !ls -lh {save_dir}\n",
+        "\n",
+        "        #@title CELL 5 — Upload to Hugging Face\n",
+        "        from huggingface_hub import HfApi, create_repo\n",
+        "        import os\n",
+        "\n",
+        "        repo_id = \"codeShare/flux-3-image-klein-sdnq-int4\"   # ← change if you want\n",
+        "\n",
+        "        api = HfApi()\n",
+        "        try:\n",
+        "            if not api.repo_exists(repo_id=repo_id, repo_type=\"model\"):\n",
+        "                create_repo(repo_id=repo_id, repo_type=\"model\", private=False, token=hf_token)\n",
+        "                print(\"Repo created\")\n",
+        "            else:\n",
+        "                print(\"Repo already exists\")\n",
+        "        except Exception as e:\n",
+        "            print(e)\n",
+        "\n",
+        "        print(\"Uploading transformer folder...\")\n",
+        "        api.upload_folder(\n",
+        "            folder_path=\"/kaggle/working/flux3-klein-sdnq-int4/transformer\",\n",
+        "            repo_id=repo_id,\n",
+        "            repo_type=\"model\",\n",
+        "            path_in_repo=\"transformer\",\n",
+        "            commit_message=\"SDNQ int4 quantized Flux3Transformer2DModel (split quantization)\",\n",
+        "        )\n",
+        "\n",
+        "        print(f\"\\n🎉 Done! → https://huggingface.co/{repo_id}\")\n",
+        "\n",
+        "        #@title CELL 6 — Quantize Text Encoder\n",
+        "        from transformers import AutoModel\n",
+        "        from sdnq import sdnq_post_load_quant\n",
+        "        import torch, gc, os\n",
+        "\n",
+        "        def free():\n",
+        "            gc.collect()\n",
+        "            torch.cuda.empty_cache()\n",
+        "\n",
+        "        print(\"Loading Text Encoder (Qwen3-VL-4B) on CPU...\")\n",
+        "        text_encoder = AutoModel.from_pretrained(\n",
+        "            \"black-forest-labs/flux-3-image-klein\",\n",
+        "            subfolder=\"text_encoder\",\n",
+        "            torch_dtype=torch.float16,\n",
+        "            low_cpu_mem_usage=True,\n",
+        "            device_map=\"cpu\",\n",
+        "            token=hf_token,\n",
+        "        )\n",
+        "\n",
+        "        print(\"Applying SDNQ int4 to Text Encoder...\")\n",
+        "        text_encoder = sdnq_post_load_quant(\n",
+        "            text_encoder,\n",
+        "            weights_dtype=\"int4\",\n",
+        "            group_size=0,\n",
+        "            use_svd=False,\n",
+        "            quant_conv=False,\n",
+        "            quant_embedding=False,          # keep embeddings full precision\n",
+        "            use_quantized_matmul=True,\n",
+        "            dequantize_fp32=True,\n",
+        "            quantization_device=\"cuda:0\",\n",
+        "            return_device=\"cpu\",\n",
+        "            modules_to_not_convert=[\n",
+        "                \"embed_tokens\",\n",
+        "                \"lm_head\",\n",
+        "                \"model.norm\",\n",
+        "                \"model.rotary_emb\",\n",
+        "                \"visual\",                   # vision tower\n",
+        "            ],\n",
+        "        )\n",
+        "\n",
+        "        os.makedirs(\"/kaggle/working/flux3-klein-sdnq-int4/text_encoder\", exist_ok=True)\n",
+        "        text_encoder.save_pretrained(\n",
+        "            \"/kaggle/working/flux3-klein-sdnq-int4/text_encoder\",\n",
+        "            safe_serialization=True\n",
+        "        )\n",
+        "        print(\"✅ Text Encoder quantized & saved\")\n",
+        "\n",
+        "        del text_encoder\n",
+        "        free()\n",
+        "\n",
+        "        #@title CELL 7 — Quantize Prompt Upsampler (9B)\n",
+        "        from transformers import AutoModelForCausalLM\n",
+        "        from sdnq import sdnq_post_load_quant\n",
+        "        import torch, gc, os\n",
+        "\n",
+        "        print(\"Loading Prompt Upsampler (9B) on CPU (this takes time & RAM)...\")\n",
+        "        upsampler = AutoModelForCausalLM.from_pretrained(\n",
+        "            \"black-forest-labs/flux-3-image-klein-pup\",\n",
+        "            torch_dtype=torch.float16,\n",
+        "            low_cpu_mem_usage=True,\n",
+        "            device_map=\"cpu\",\n",
+        "            token=hf_token,\n",
+        "        )\n",
+        "\n",
+        "        print(\"Applying SDNQ int4 to Prompt Upsampler...\")\n",
+        "        upsampler = sdnq_post_load_quant(\n",
+        "            upsampler,\n",
+        "            weights_dtype=\"int4\",\n",
+        "            group_size=0,\n",
+        "            use_svd=False,\n",
+        "            quant_conv=False,\n",
+        "            quant_embedding=False,\n",
+        "            use_quantized_matmul=True,\n",
+        "            dequantize_fp32=True,\n",
+        "            quantization_device=\"cuda:0\",\n",
+        "            return_device=\"cpu\",\n",
+        "            modules_to_not_convert=[\n",
+        "                \"embed_tokens\",\n",
+        "                \"lm_head\",\n",
+        "                \"model.norm\",\n",
+        "                \"model.rotary_emb\",\n",
+        "                \"model.layers.0\",           # first layer\n",
+        "                \"model.layers.35\",          # last layer (adjust if different)\n",
+        "            ],\n",
+        "        )\n",
+        "\n",
+        "        os.makedirs(\"/kaggle/working/flux3-klein-sdnq-int4/prompt_upsampler\", exist_ok=True)\n",
+        "        upsampler.save_pretrained(\n",
+        "            \"/kaggle/working/flux3-klein-sdnq-int4/prompt_upsampler\",\n",
+        "            safe_serialization=True\n",
+        "        )\n",
+        "        print(\"✅ Prompt Upsampler quantized & saved\")\n",
+        "\n",
+        "        del upsampler\n",
+        "        free()\n",
+        "\n",
+        "        #@title CELL 8 — Copy VAE + tokenizer + scheduler + config files\n",
+        "        from huggingface_hub import snapshot_download\n",
+        "        import shutil, os\n",
+        "\n",
+        "        base_dir = \"/kaggle/working/flux3-klein-sdnq-int4\"\n",
+        "        os.makedirs(base_dir, exist_ok=True)\n",
+        "\n",
+        "        print(\"Downloading remaining components from original repo...\")\n",
+        "        tmp = snapshot_download(\n",
+        "            repo_id=\"black-forest-labs/flux-3-image-klein\",\n",
+        "            token=hf_token,\n",
+        "            allow_patterns=[\n",
+        "                \"vae/*\",\n",
+        "                \"tokenizer/*\",\n",
+        "                \"scheduler/*\",\n",
+        "                \"model_index.json\",\n",
+        "                \"*.json\",\n",
+        "                \"README.md\",\n",
+        "            ],\n",
+        "            local_dir=\"/kaggle/working/tmp_flux3\",\n",
+        "        )\n",
+        "\n",
+        "        # Copy the needed folders\n",
+        "        for folder in [\"vae\", \"tokenizer\", \"scheduler\"]:\n",
+        "            src = os.path.join(tmp, folder)\n",
+        "            dst = os.path.join(base_dir, folder)\n",
+        "            if os.path.exists(src):\n",
+        "                if os.path.exists(dst):\n",
+        "                    shutil.rmtree(dst)\n",
+        "                shutil.copytree(src, dst)\n",
+        "                print(f\"✅ Copied {folder}\")\n",
+        "\n",
+        "        # Copy model_index.json and other root files\n",
+        "        for f in [\"model_index.json\", \"README.md\"]:\n",
+        "            src = os.path.join(tmp, f)\n",
+        "            if os.path.exists(src):\n",
+        "                shutil.copy2(src, base_dir)\n",
+        "                print(f\"✅ Copied {f}\")\n",
+        "\n",
+        "        print(\"✅ All supporting components ready\")\n",
+        "\n",
+        "        #@title CELL 9 — Create public repo & Upload\n",
+        "        from huggingface_hub import HfApi, create_repo\n",
+        "        from huggingface_hub.utils import HfHubHTTPError\n",
+        "        import os\n",
+        "\n",
+        "        # ====== CHANGE THIS IF YOU WANT A DIFFERENT NAME ======\n",
+        "        repo_id = \"codeShare/flux-3-image-klein-sdnq-int4\"\n",
+        "        # ======================================================\n",
+        "\n",
+        "        api = HfApi()\n",
+        "\n",
+        "        print(f\"Creating / checking public repository: {repo_id}\")\n",
+        "        try:\n",
+        "            if not api.repo_exists(repo_id=repo_id, repo_type=\"model\"):\n",
+        "                create_repo(\n",
+        "                    repo_id=repo_id,\n",
+        "                    repo_type=\"model\",\n",
+        "                    private=False,          # ← public\n",
+        "                    token=hf_token,\n",
+        "                    exist_ok=True,\n",
+        "                )\n",
+        "                print(\"✅ Public repository created\")\n",
+        "            else:\n",
+        "                print(\"✅ Repository already exists\")\n",
+        "        except Exception as e:\n",
+        "            print(\"Repo check/create error:\", e)\n",
+        "\n",
+        "        # Upload the entire folder structure\n",
+        "        print(\"\\nUploading full model (this may take a while)...\")\n",
+        "        api.upload_folder(\n",
+        "            folder_path=\"/kaggle/working/flux3-klein-sdnq-int4\",\n",
+        "            repo_id=repo_id,\n",
+        "            repo_type=\"model\",\n",
+        "            commit_message=\"SDNQ int4 quantized FLUX 3 Image Klein (transformer + text_encoder + prompt_upsampler)\",\n",
+        "            token=hf_token,\n",
+        "        )\n",
+        "\n",
+        "        print(\"\\n🎉 Upload complete!\")\n",
+        "        print(f\"Public model available at: https://huggingface.co/{repo_id}\")"
+      ],
+      "metadata": {
+        "id": "SII5WEML4tCf"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}