Delete kaggle_prune_loras.ipynb

kaggle_prune_loras.ipynb

@@ -1,565 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "507c1488",
-      "metadata": {
-        "execution": {
-          "iopub.execute_input": "2026-05-14T18:09:45.284673Z",
-          "iopub.status.busy": "2026-05-14T18:09:45.284222Z",
-          "iopub.status.idle": "2026-05-14T18:10:01.729025Z",
-          "shell.execute_reply": "2026-05-14T18:10:01.727975Z"
-        },
-        "papermill": {
-          "duration": 16.450904,
-          "end_time": "2026-05-14T18:10:01.730955+00:00",
-          "exception": false,
-          "start_time": "2026-05-14T18:09:45.280051+00:00",
-          "status": "completed"
-        },
-        "tags": [],
-        "id": "507c1488"
-      },
-      "outputs": [],
-      "source": [
-        "# =============================================================================\n",
-        "# CELL 1: Install dependencies\n",
-        "# =============================================================================\n",
-        "!pip install -q safetensors torch matplotlib numpy huggingface_hub pynacl py7zr\n",
-        "\n",
-        "import os\n",
-        "import torch\n",
-        "import gc\n",
-        "import random\n",
-        "import datetime\n",
-        "\n",
-        "print(f\"✅ PyTorch version: {torch.__version__}\")\n",
-        "print(f\"✅ Available GPUs: {torch.cuda.device_count()}\")\n",
-        "for i in range(torch.cuda.device_count()):\n",
-        "    print(f\"   GPU {i}: {torch.cuda.get_device_name(i)}\")"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "fc6693b0",
-      "metadata": {
-        "execution": {
-          "iopub.execute_input": "2026-05-14T18:10:01.737730Z",
-          "iopub.status.busy": "2026-05-14T18:10:01.736685Z",
-          "iopub.status.idle": "2026-05-14T18:10:03.127601Z",
-          "shell.execute_reply": "2026-05-14T18:10:03.126560Z"
-        },
-        "papermill": {
-          "duration": 1.395897,
-          "end_time": "2026-05-14T18:10:03.129339+00:00",
-          "exception": false,
-          "start_time": "2026-05-14T18:10:01.733442+00:00",
-          "status": "completed"
-        },
-        "tags": [],
-        "id": "fc6693b0"
-      },
-      "outputs": [],
-      "source": [
-        "# =============================================================================\n",
-        "# CELL 2: Secrets + Config from Kaggle Dataset\n",
-        "# =============================================================================\n",
-        "from kaggle_secrets import UserSecretsClient\n",
-        "from huggingface_hub import snapshot_download, login\n",
-        "import torch\n",
-        "import safetensors.torch\n",
-        "from safetensors import safe_open\n",
-        "import os\n",
-        "import random\n",
-        "import datetime\n",
-        "import gc\n",
-        "from pathlib import Path\n",
-        "from concurrent.futures import ThreadPoolExecutor, as_completed\n",
-        "from collections import defaultdict\n",
-        "\n",
-        "print(\"✅ Libraries imported!\")\n",
-        "\n",
-        "# === Kaggle Dataset Path ===\n",
-        "kaggle_repo_path = \"/kaggle/input/datasets/nekos4lyfe/image-caption-dataset/\"  #@param {type:\"string\"}\n",
-        "\n",
-        "# Read HF_TOKEN from HF_TOKEN.txt\n",
-        "hf_token = None\n",
-        "try:\n",
-        "    token_path = Path(kaggle_repo_path) / \"HF_TOKEN.txt\"\n",
-        "    if token_path.exists():\n",
-        "        hf_token = token_path.read_text(encoding=\"utf-8\").strip()\n",
-        "        print(\"✅ HF_TOKEN loaded from HF_TOKEN.txt\")\n",
-        "\n",
-        "        if hf_token:\n",
-        "            login(token=hf_token)\n",
-        "            print(\"✅ Successfully logged into Hugging Face\")\n",
-        "    else:\n",
-        "        print(f\"⚠️ HF_TOKEN.txt not found at {token_path}\")\n",
-        "except Exception as e:\n",
-        "    print(f\"⚠️ Failed to read HF_TOKEN.txt: {e}\")"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "d3cddbf0",
-      "metadata": {
-        "execution": {
-          "iopub.execute_input": "2026-05-14T18:10:03.140540Z",
-          "iopub.status.busy": "2026-05-14T18:10:03.139445Z",
-          "iopub.status.idle": "2026-05-14T18:10:03.153972Z",
-          "shell.execute_reply": "2026-05-14T18:10:03.152857Z"
-        },
-        "papermill": {
-          "duration": 0.019317,
-          "end_time": "2026-05-14T18:10:03.155565+00:00",
-          "exception": false,
-          "start_time": "2026-05-14T18:10:03.136248+00:00",
-          "status": "completed"
-        },
-        "tags": [],
-        "id": "d3cddbf0"
-      },
-      "outputs": [],
-      "source": [
-        "# =============================================================================\n",
-        "# CELL 3: Setup Folders\n",
-        "# =============================================================================\n",
-        "base_dir = \"/kaggle/working/pruned_loras\"\n",
-        "os.makedirs(base_dir, exist_ok=True)\n",
-        "os.makedirs(f\"{base_dir}/processed\", exist_ok=True)\n",
-        "os.makedirs(f\"{base_dir}/metadata\", exist_ok=True)\n",
-        "\n",
-        "print(f\"Working directory: {base_dir}\")\n",
-        "\n",
-        "# Read repo_id from repo_id.txt\n",
-        "repo_id = None\n",
-        "try:\n",
-        "    repo_id_path = Path(kaggle_repo_path) / \"repo_id.txt\"\n",
-        "    if repo_id_path.exists():\n",
-        "        repo_id = repo_id_path.read_text(encoding=\"utf-8\").strip()\n",
-        "        print(\"✅ repo_id loaded from repo_id.txt\")\n",
-        "    else:\n",
-        "        print(f\"⚠️ repo_id.txt not found at {repo_id_path}\")\n",
-        "except Exception as e:\n",
-        "    print(f\"⚠️ Failed to read repo_id.txt: {e}\")\n",
-        "#-----#"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "d3005a43",
-      "metadata": {
-        "execution": {
-          "iopub.execute_input": "2026-05-14T18:10:03.161814Z",
-          "iopub.status.busy": "2026-05-14T18:10:03.161246Z",
-          "iopub.status.idle": "2026-05-14T18:10:26.771985Z",
-          "shell.execute_reply": "2026-05-14T18:10:26.770854Z"
-        },
-        "papermill": {
-          "duration": 23.615718,
-          "end_time": "2026-05-14T18:10:26.773639+00:00",
-          "exception": false,
-          "start_time": "2026-05-14T18:10:03.157921+00:00",
-          "status": "completed"
-        },
-        "tags": [],
-        "id": "d3005a43"
-      },
-      "outputs": [],
-      "source": [
-        "repo_id = \"codeShare/flux-klein-colorize-lora\"  #@param {type:\"string\"}\n",
-        "#\"Realism_Engine_Klein_V2.*\",\n",
-        "#\"Flux.2 Klein 9B - Thong Panties.*\" , \"F2K9B_chairtied_cha1rt1ed_V2E10.*\", \"klein_snofs_v1_2.*\" , \"f2k_consist_20260225.*\" , \"darkBeastMar2126Latest_dbkBlitzV15.*\"],\n",
-        "# =============================================================================\n",
-        "# CELL 4: Download + Smart Letter Naming\n",
-        "# =============================================================================\n",
-        "print(f\"Downloading .safetensors from {repo_id} ...\")\n",
-        "\n",
-        "snapshot_download(\n",
-        "    repo_id=repo_id,\n",
-        "    local_dir=base_dir,\n",
-        "    token=hf_token,\n",
-        "    ignore_patterns=[\"*.md\", \"*.txt\", \"*.json\", \"*.png\", \"*.jpg\"],\n",
-        ")\n",
-        "\n",
-        "original_files = sorted([f for f in os.listdir(base_dir) if f.endswith(\".safetensors\")])\n",
-        "print(f\"✅ Downloaded {len(original_files)} LoRA files.\")\n",
-        "\n",
-        "# ====================== SMART LETTER GENERATOR ======================\n",
-        "def generate_letter_labels(n):\n",
-        "    labels = []\n",
-        "    i = 0\n",
-        "    while len(labels) < n:\n",
-        "        if i < 26:\n",
-        "            labels.append(chr(65 + i))\n",
-        "        else:\n",
-        "            first = chr(65 + (i - 26) // 26)\n",
-        "            second = chr(65 + (i - 26) % 26)\n",
-        "            labels.append(first + second)\n",
-        "        i += 1\n",
-        "    return labels\n",
-        "\n",
-        "letters = generate_letter_labels(len(original_files))\n",
-        "\n",
-        "# Create mapping file BEFORE renaming\n",
-        "mapping_path = os.path.join(base_dir, \"original_mapping.txt\")\n",
-        "with open(mapping_path, \"w\", encoding=\"utf-8\") as f:\n",
-        "    f.write(\"Original Name → New Short Name\\n\")\n",
-        "    f.write(\"=\" * 70 + \"\\n\")\n",
-        "    for old_name, letter in zip(original_files, letters):\n",
-        "        f.write(f\"{old_name}  →  {letter}.safetensors\\n\")\n",
-        "\n",
-        "print(f\"✅ Mapping saved to: {mapping_path}\")\n",
-        "\n",
-        "# Rename files\n",
-        "lora_files = []\n",
-        "for old_name, letter in zip(original_files, letters):\n",
-        "    new_name = f\"{letter}.safetensors\"\n",
-        "    old_path = os.path.join(base_dir, old_name)\n",
-        "    new_path = os.path.join(base_dir, new_name)\n",
-        "\n",
-        "    os.rename(old_path, new_path)\n",
-        "    lora_files.append(new_name)\n",
-        "    print(f\"   {old_name}  →  {new_name}\")\n",
-        "\n",
-        "print(f\"✅ All files renamed using A-Z + AA, AB... system.\")"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "d328be3b",
-      "metadata": {
-        "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
-        "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
-        "execution": {
-          "iopub.execute_input": "2026-05-14T18:10:26.781049Z",
-          "iopub.status.busy": "2026-05-14T18:10:26.780630Z",
-          "iopub.status.idle": "2026-05-14T21:19:09.863745Z",
-          "shell.execute_reply": "2026-05-14T21:19:09.862844Z"
-        },
-        "papermill": {
-          "duration": 11323.149894,
-          "end_time": "2026-05-14T21:19:09.926355+00:00",
-          "exception": false,
-          "start_time": "2026-05-14T18:10:26.776461+00:00",
-          "status": "completed"
-        },
-        "tags": [],
-        "id": "d328be3b"
-      },
-      "outputs": [],
-      "source": [
-        "# =============================================================================\n",
-        "# CELL 5: Pruning - Supports Regular LoRA + LoKr (Kronecker)\n",
-        "# =============================================================================\n",
-        "from collections import defaultdict\n",
-        "import time\n",
-        "import datetime\n",
-        "import os\n",
-        "import random\n",
-        "import gc\n",
-        "import torch\n",
-        "from concurrent.futures import ThreadPoolExecutor, as_completed\n",
-        "from pathlib import Path\n",
-        "from safetensors import safe_open\n",
-        "\n",
-        "desired_accuracy = 85  #@param {type:\"slider\", min:80, max:100, step:1}\n",
-        "\n",
-        "print(f\"🎯 Target Accuracy: {desired_accuracy}% | LoRA + LoKr Support\")\n",
-        "\n",
-        "# ====================== LOAD ORIGINAL NAME MAPPING ======================\n",
-        "original_to_letter = {}\n",
-        "mapping_path = os.path.join(base_dir, \"original_mapping.txt\")\n",
-        "if os.path.exists(mapping_path):\n",
-        "    with open(mapping_path, \"r\", encoding=\"utf-8\") as f:\n",
-        "        for line in f:\n",
-        "            if \"→\" in line:\n",
-        "                parts = line.strip().split(\"→\")\n",
-        "                if len(parts) == 2:\n",
-        "                    old = parts[0].strip()\n",
-        "                    new = parts[1].strip()\n",
-        "                    original_to_letter[new] = old\n",
-        "    print(f\"✅ Loaded {len(original_to_letter)} original filename mappings\")\n",
-        "else:\n",
-        "    print(\"⚠️ original_mapping.txt not found - using short names\")\n",
-        "\n",
-        "# ====================== WORKER FUNCTION ======================\n",
-        "def worker(thread_id: int, gpu_id: int, file_list: list):\n",
-        "    print(f\"[Thread {thread_id} | GPU {gpu_id}] 🚀 Started with {len(file_list)} files\")\n",
-        "    torch.cuda.set_device(gpu_id)\n",
-        "\n",
-        "    for idx, filename in enumerate(file_list):\n",
-        "        letter = filename.replace(\".safetensors\", \"\")\n",
-        "        input_path = os.path.join(base_dir, filename)\n",
-        "        size_before = os.path.getsize(input_path) / (1024 * 1024)\n",
-        "\n",
-        "        print(f\"[Thread {thread_id} | GPU {gpu_id}] 🔄 Processing [{letter}] {filename} ({size_before:.2f} MB)\")\n",
-        "\n",
-        "        torch.cuda.empty_cache()\n",
-        "        gc.collect()\n",
-        "\n",
-        "        original_filename = original_to_letter.get(filename, filename)\n",
-        "\n",
-        "        random_suffix = random.randint(10000, 99999)\n",
-        "        output_name = f\"{letter}_{random_suffix}.safetensors\"\n",
-        "        output_path = f\"{base_dir}/processed/{output_name}\"\n",
-        "\n",
-        "        # Load file\n",
-        "        state_dict = safetensors.torch.load_file(input_path, device=\"cpu\")\n",
-        "\n",
-        "        original_metadata = {}\n",
-        "        try:\n",
-        "            with safe_open(input_path, framework=\"pt\", device=\"cpu\") as f:\n",
-        "                original_metadata = f.metadata() or {}\n",
-        "        except:\n",
-        "            pass\n",
-        "\n",
-        "        # ====================== PARSE LAYERS (LoRA + LoKr) ======================\n",
-        "        lora_pairs = defaultdict(dict)\n",
-        "        original_ranks = {}\n",
-        "        is_lokr = False\n",
-        "\n",
-        "        for key, tensor in state_dict.items():\n",
-        "            if \".lokr_\" in key:\n",
-        "                is_lokr = True\n",
-        "                # Extract base key\n",
-        "                base = key.split(\".lokr_\")[0]\n",
-        "\n",
-        "                if \".lokr_w1\" in key:\n",
-        "                    lora_pairs[base][\"w1\"] = tensor\n",
-        "                    original_ranks[base] = tensor.shape[0] * tensor.shape[1]  # approximate full rank\n",
-        "                elif \".lokr_w2\" in key:\n",
-        "                    lora_pairs[base][\"w2\"] = tensor\n",
-        "                elif \".lokr_w\" in key:   # some LoKr have single lokr_w\n",
-        "                    lora_pairs[base][\"w\"] = tensor\n",
-        "                    original_ranks[base] = tensor.shape[0]\n",
-        "\n",
-        "            elif \".lora_A.weight\" in key or \".lora_down.weight\" in key:\n",
-        "                base = key.replace(\".lora_A.weight\", \"\").replace(\".lora_down.weight\", \"\")\n",
-        "                lora_pairs[base][\"A\"] = tensor\n",
-        "                original_ranks[base] = tensor.shape[0]\n",
-        "            elif \".lora_B.weight\" in key or \".lora_up.weight\" in key:\n",
-        "                base = key.replace(\".lora_B.weight\", \"\").replace(\".lora_up.weight\", \"\")\n",
-        "                lora_pairs[base][\"B\"] = tensor\n",
-        "\n",
-        "        # Pruning\n",
-        "        new_state_dict = dict(state_dict)\n",
-        "        changes_made = False\n",
-        "        pruned_count = 0\n",
-        "        total_layers = len(lora_pairs)\n",
-        "        layer_log = []\n",
-        "\n",
-        "        for base_key, matrices in lora_pairs.items():\n",
-        "            if not matrices:\n",
-        "                continue\n",
-        "\n",
-        "            # ==================== LoKr Handling ====================\n",
-        "            if \"w1\" in matrices and \"w2\" in matrices:\n",
-        "                # Reconstruct delta_W = kron(w1, w2)\n",
-        "                w1 = matrices[\"w1\"].to(gpu_id)\n",
-        "                w2 = matrices[\"w2\"].to(gpu_id)\n",
-        "                delta_W = torch.kron(w1, w2).float()\n",
-        "                orig_rank = original_ranks.get(base_key, w1.shape[0] * w1.shape[1])\n",
-        "                is_lokr_layer = True\n",
-        "            elif \"w\" in matrices:\n",
-        "                delta_W = matrices[\"w\"].to(gpu_id).float()\n",
-        "                orig_rank = original_ranks.get(base_key, delta_W.shape[0])\n",
-        "                is_lokr_layer = True\n",
-        "            # ==================== Standard LoRA ====================\n",
-        "            elif \"A\" in matrices and \"B\" in matrices:\n",
-        "                A = matrices[\"A\"].to(gpu_id)\n",
-        "                B = matrices[\"B\"].to(gpu_id)\n",
-        "                delta_W = torch.matmul(B, A).float()\n",
-        "                orig_rank = original_ranks.get(base_key, A.shape[0])\n",
-        "                is_lokr_layer = False\n",
-        "            else:\n",
-        "                continue\n",
-        "\n",
-        "            original_norm = torch.norm(delta_W, p='fro').item()\n",
-        "\n",
-        "            U, S, Vh = torch.linalg.svd(delta_W, full_matrices=False)\n",
-        "\n",
-        "            # Try reduced ranks\n",
-        "            candidates = [max(1, int(orig_rank * f)) for f in [0.95, 0.9, 0.85, 0.8, 0.75, 0.7, 0.65, 0.6]]\n",
-        "            test_ranks = sorted(set(r for r in candidates if r < orig_rank))\n",
-        "\n",
-        "            best_rank = orig_rank\n",
-        "            best_acc = 100.0\n",
-        "\n",
-        "            for r in test_ranks:\n",
-        "                if r >= len(S): continue\n",
-        "                S_trunc = torch.zeros_like(S)\n",
-        "                S_trunc[:r] = S[:r]\n",
-        "                approx = U @ torch.diag(S_trunc) @ Vh\n",
-        "                error = torch.norm(delta_W - approx, p='fro').item()\n",
-        "                rel_error = (error / original_norm * 100) if original_norm > 1e-8 else 0.0\n",
-        "                acc = 100 - rel_error\n",
-        "\n",
-        "                if acc >= desired_accuracy:\n",
-        "                    best_rank = r\n",
-        "                    best_acc = acc\n",
-        "                    break\n",
-        "\n",
-        "            if best_rank < orig_rank:\n",
-        "                changes_made = True\n",
-        "                pruned_count += 1\n",
-        "                r = best_rank\n",
-        "\n",
-        "                sqrt_S = torch.sqrt(S[:r])\n",
-        "                new_up = (U[:, :r] * sqrt_S.unsqueeze(0)).to(torch.bfloat16)\n",
-        "                new_down = (sqrt_S.unsqueeze(1) * Vh[:r, :]).to(torch.bfloat16)\n",
-        "\n",
-        "                # Remove ALL old keys for this layer\n",
-        "                for suffix in [\".lora_A.weight\", \".lora_B.weight\",\n",
-        "                              \".lora_down.weight\", \".lora_up.weight\",\n",
-        "                              \".lokr_w1\", \".lokr_w2\", \".lokr_w\", \".alpha\"]:\n",
-        "                    new_state_dict.pop(base_key + suffix, None)\n",
-        "\n",
-        "                # Save as standard LoRA (most compatible)\n",
-        "                new_state_dict[base_key + \".lora_down.weight\"] = new_down.contiguous().cpu()\n",
-        "                new_state_dict[base_key + \".lora_up.weight\"]   = new_up.contiguous().cpu()\n",
-        "\n",
-        "                print(f\"   → {base_key} | {orig_rank} → {best_rank} | Acc {best_acc:.2f}% {'(LoKr)' if is_lokr_layer else ''}\")\n",
-        "                layer_log.append(f\"{base_key} | {orig_rank:3} → {best_rank:3} | Pruned | Acc {best_acc:.2f}% {'(LoKr)' if is_lokr_layer else ''}\")\n",
-        "            else:\n",
-        "                layer_log.append(f\"{base_key} | {orig_rank:3} → {orig_rank:3} | No change\")\n",
-        "\n",
-        "            # Cleanup\n",
-        "            del delta_W, U, S, Vh\n",
-        "            if 'w1' in locals(): del w1\n",
-        "            if 'w2' in locals(): del w2\n",
-        "            torch.cuda.empty_cache()\n",
-        "\n",
-        "        # Delete original\n",
-        "        if os.path.exists(input_path):\n",
-        "            os.remove(input_path)\n",
-        "\n",
-        "        if not changes_made:\n",
-        "            print(f\"[Thread {thread_id} | GPU {gpu_id}] → No pruning needed for [{letter}]\")\n",
-        "            continue\n",
-        "\n",
-        "        # ====================== SAVE FILE ======================\n",
-        "        new_metadata = dict(original_metadata)\n",
-        "        new_metadata.update({\n",
-        "            \"original_file\": original_filename,\n",
-        "            \"pruned_with\": f\"SVD Rank Reduction at {desired_accuracy}% accuracy\",\n",
-        "            \"pruning_date\": datetime.datetime.now().isoformat(),\n",
-        "            \"random_id\": str(random_suffix),\n",
-        "            \"layers_pruned\": f\"{pruned_count}/{total_layers}\",\n",
-        "            \"note\": \"Converted LoKr to standard LoRA where applicable\"\n",
-        "        })\n",
-        "\n",
-        "        for k, v in new_state_dict.items():\n",
-        "            if isinstance(v, torch.Tensor):\n",
-        "                new_state_dict[k] = v.contiguous()\n",
-        "\n",
-        "        safetensors.torch.save_file(new_state_dict, output_path, metadata=new_metadata)\n",
-        "\n",
-        "        size_after = os.path.getsize(output_path) / (1024 * 1024)\n",
-        "\n",
-        "        # Save metadata log\n",
-        "        meta_dir = f\"{base_dir}/metadata/{letter}\"\n",
-        "        os.makedirs(meta_dir, exist_ok=True)\n",
-        "        with open(f\"{meta_dir}/{letter}_metadata.txt\", \"w\", encoding=\"utf-8\") as f:\n",
-        "            f.write(f\"Original filename: {original_filename}\\n\")\n",
-        "            f.write(f\"Pruned filename : {output_name}\\n\")\n",
-        "            f.write(f\"Size Before     : {size_before:.2f} MB\\n\")\n",
-        "            f.write(f\"Size After      : {size_after:.2f} MB\\n\")\n",
-        "            f.write(f\"Layers Pruned   : {pruned_count}/{total_layers}\\n\\n\")\n",
-        "            f.write(\"=== LAYER DETAILS ===\\n\")\n",
-        "            for line in layer_log:\n",
-        "                f.write(line + \"\\n\")\n",
-        "\n",
-        "        print(f\"[Thread {thread_id} | GPU {gpu_id}] ✅ Saved [{letter}] | {size_before:.1f}MB → {size_after:.1f}MB\")\n",
-        "\n",
-        "        del state_dict, new_state_dict\n",
-        "        torch.cuda.empty_cache()\n",
-        "        gc.collect()\n",
-        "\n",
-        "    print(f\"[Thread {thread_id} | GPU {gpu_id}] 🏁 Worker completed\")\n",
-        "    return True\n",
-        "\n",
-        "\n",
-        "# ====================== LAUNCH THREADS ======================\n",
-        "print(f\"\\nDistributing {len(lora_files)} files...\")\n",
-        "\n",
-        "num_threads = 2\n",
-        "chunks = [[] for _ in range(num_threads)]\n",
-        "for i, f in enumerate(lora_files):\n",
-        "    chunks[i % num_threads].append(f)\n",
-        "\n",
-        "with ThreadPoolExecutor(max_workers=num_threads) as executor:\n",
-        "    futures = []\n",
-        "    for t in range(num_threads):\n",
-        "        gpu_id = t % 2\n",
-        "        future = executor.submit(worker, t, gpu_id, chunks[t])\n",
-        "        futures.append(future)\n",
-        "        print(f\"   → Thread {t} on GPU {gpu_id} ({len(chunks[t])} files)\")\n",
-        "        if t < num_threads - 1:\n",
-        "            time.sleep(15)\n",
-        "\n",
-        "    for future in as_completed(futures):\n",
-        "        future.result()\n",
-        "\n",
-        "print(\"\\n🎉 All pruning completed! (LoRA + LoKr supported)\")"
-      ]
-    }
-  ],
-  "metadata": {
-    "kaggle": {
-      "accelerator": "nvidiaTeslaT4",
-      "dataSources": [
-        {
-          "databundleVersionId": 17239359,
-          "datasetId": 8022630,
-          "sourceId": 16255844,
-          "sourceType": "datasetVersion"
-        }
-      ],
-      "dockerImageVersionId": 31329,
-      "isGpuEnabled": true,
-      "isInternetEnabled": true,
-      "language": "python",
-      "sourceType": "notebook"
-    },
-    "kernelspec": {
-      "display_name": "Python 3",
-      "language": "python",
-      "name": "python3"
-    },
-    "language_info": {
-      "codemirror_mode": {
-        "name": "ipython",
-        "version": 3
-      },
-      "file_extension": ".py",
-      "mimetype": "text/x-python",
-      "name": "python",
-      "nbconvert_exporter": "python",
-      "pygments_lexer": "ipython3",
-      "version": "3.12.12"
-    },
-    "papermill": {
-      "default_parameters": {},
-      "duration": 11372.148303,
-      "end_time": "2026-05-14T21:19:13.559262+00:00",
-      "environment_variables": {},
-      "exception": null,
-      "input_path": "__notebook__.ipynb",
-      "output_path": "__notebook__.ipynb",
-      "parameters": {},
-      "start_time": "2026-05-14T18:09:41.410959+00:00",
-      "version": "2.7.0"
-    },
-    "colab": {
-      "provenance": []
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 5
-}