Upload prune_lora.ipynb

prune_lora.ipynb

@@ -0,0 +1,306 @@
+{
+  "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": [
+        "# Process all LoRa safetensors in huggingface repo"
+      ],
+      "metadata": {
+        "id": "AlccmYv2yH5V"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@markdown **Cell 1** - Install dependencies\n",
+        "!pip install -q safetensors torch matplotlib numpy huggingface_hub\n",
+        "\n",
+        "#@markdown **Cell 2** - Import libraries + Login with HF_TOKEN\n",
+        "import torch\n",
+        "import safetensors.torch\n",
+        "import matplotlib.pyplot as plt\n",
+        "import numpy as np\n",
+        "from collections import defaultdict\n",
+        "import os\n",
+        "import json\n",
+        "import shutil\n",
+        "from google.colab import drive, files\n",
+        "from huggingface_hub import snapshot_download, HfApi\n",
+        "import getpass\n",
+        "\n",
+        "print(\"✅ Libraries imported!\")\n",
+        "\n",
+        "# Use HF_TOKEN from Colab Secrets for faster downloads\n",
+        "from google.colab import userdata\n",
+        "hf_token = userdata.get('HF_TOKEN')\n",
+        "if hf_token:\n",
+        "    print(\"✅ HF_TOKEN loaded from secrets\")\n",
+        "else:\n",
+        "    print(\"⚠️ HF_TOKEN not found in secrets. You may need to add it.\")\n",
+        "\n",
+        "#@markdown **Cell 3** - Mount Drive + Create Working Folders\n",
+        "drive.mount('/content/drive')\n",
+        "\n",
+        "base_dir = \"/content/Klein_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"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "ZkAw7Xp_zCcY"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@markdown **Cell 4** - Download All LoRAs from Hugging Face\n",
+        "#repo_id = \"Winnougan/Must_Have_Klein_9b_loras\"\n",
+        "\n",
+        "repo_id = '' #@param {type:'string'}\n",
+        "\n",
+        "print(f\"Downloading all files from {repo_id} ... (this may take a while)\")\n",
+        "\n",
+        "# Download all .safetensors files\n",
+        "snapshot_download(\n",
+        "    repo_id=repo_id,\n",
+        "    local_dir=base_dir,\n",
+        "    allow_patterns=\"*.safetensors\",\n",
+        "    token=hf_token,\n",
+        "    ignore_patterns=[\"*.md\", \"*.txt\", \"*.json\"]  # skip non-lora files if any\n",
+        ")\n",
+        "\n",
+        "# Get list of downloaded safetensors\n",
+        "lora_files = sorted([f for f in os.listdir(base_dir) if f.endswith(\".safetensors\")])\n",
+        "print(f\"✅ Downloaded {len(lora_files)} LoRA files:\")\n",
+        "for i, f in enumerate(lora_files):\n",
+        "    print(f\"   {i+1:2d}. {f}\")"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "8Y2gIsvRzMLl"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@markdown **Cell 5** - Main Processing: SVD Pruning at 90% Accuracy\n",
+        "\n",
+        "desired_accuracy = 90  #@param {type:'slider', min:80, step:1, max:100}\n",
+        "\n",
+        "max_allowed_error = 100 - desired_accuracy\n",
+        "print(f\"🎯 Target Accuracy: {desired_accuracy}% | Max Error: {max_allowed_error}%\")\n",
+        "\n",
+        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+        "print(f\"Using device: {device}\")\n",
+        "\n",
+        "import random\n",
+        "import datetime\n",
+        "from safetensors import safe_open\n",
+        "from safetensors.torch import save_file\n",
+        "\n",
+        "processed_files = []\n",
+        "mapping = {}  # original -> new letter name\n",
+        "\n",
+        "letters = [chr(65 + i) for i in range(30)]  # A to Z, then more if needed\n",
+        "\n",
+        "for idx, filename in enumerate(lora_files):\n",
+        "    input_path = os.path.join(base_dir, filename)\n",
+        "    letter = letters[idx]\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",
+        "    print(f\"\\n🔄 Processing [{letter}] {filename} ...\")\n",
+        "\n",
+        "    # === Load original metadata if it exists ===\n",
+        "    original_metadata = {}\n",
+        "    try:\n",
+        "        with safe_open(input_path, framework=\"pt\", device=\"cpu\") as f:\n",
+        "            original_metadata = f.metadata() or {}\n",
+        "        if original_metadata:\n",
+        "            print(f\"   📋 Found original metadata ({len(original_metadata)} keys)\")\n",
+        "        else:\n",
+        "            print(f\"   📋 No metadata found in original file\")\n",
+        "    except Exception as e:\n",
+        "        print(f\"   ⚠️ Could not read metadata: {e}\")\n",
+        "\n",
+        "    # Load tensors\n",
+        "    state_dict = safetensors.torch.load_file(input_path)\n",
+        "    lora_pairs = defaultdict(dict)\n",
+        "    original_ranks = {}\n",
+        "\n",
+        "    for key, tensor in state_dict.items():\n",
+        "        if \"lora_A.weight\" in key:\n",
+        "            base_key = key.replace(\".lora_A.weight\", \"\")\n",
+        "            lora_pairs[base_key][\"A\"] = tensor\n",
+        "            original_ranks[base_key] = tensor.shape[0]\n",
+        "        elif \"lora_B.weight\" in key:\n",
+        "            base_key = key.replace(\".lora_B.weight\", \"\")\n",
+        "            lora_pairs[base_key][\"B\"] = tensor\n",
+        "\n",
+        "    new_state_dict = state_dict.copy()\n",
+        "\n",
+        "    for base_key, matrices in lora_pairs.items():\n",
+        "        if \"A\" not in matrices or \"B\" not in matrices:\n",
+        "            continue\n",
+        "\n",
+        "        A = matrices[\"A\"].to(device)\n",
+        "        B = matrices[\"B\"].to(device)\n",
+        "        orig_rank = original_ranks[base_key]\n",
+        "\n",
+        "        delta_W = torch.matmul(B, A)\n",
+        "        delta_W_fp32 = delta_W.to(torch.float32)\n",
+        "        original_norm = torch.norm(delta_W_fp32, p='fro').item()\n",
+        "\n",
+        "        U, S, Vh = torch.linalg.svd(delta_W_fp32, full_matrices=False)\n",
+        "\n",
+        "        # Find lowest rank meeting accuracy\n",
+        "        best_rank = orig_rank\n",
+        "        best_error = 0.0\n",
+        "        best_acc = 100.0\n",
+        "\n",
+        "        candidates = [max(1, int(orig_rank * f)) for f in [0.9,0.8,0.7,0.6,0.5,0.4,0.3,0.2,0.1]]\n",
+        "        test_ranks = sorted(set(r for r in candidates if r < orig_rank))\n",
+        "\n",
+        "        for r in test_ranks:\n",
+        "            if r >= len(S):\n",
+        "                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_fp32 - 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_error = rel_error\n",
+        "                best_acc = acc\n",
+        "                break\n",
+        "\n",
+        "        # Reconstruct low-rank A/B\n",
+        "        r = best_rank\n",
+        "        sqrt_S = torch.sqrt(S[:r])\n",
+        "        new_B = (U[:, :r] * sqrt_S.unsqueeze(0)).to(A.dtype)\n",
+        "        new_A = (sqrt_S.unsqueeze(1) * Vh[:r, :]).to(A.dtype)\n",
+        "\n",
+        "        a_key = base_key + \".lora_A.weight\"\n",
+        "        b_key = base_key + \".lora_B.weight\"\n",
+        "        new_state_dict[a_key] = new_A.contiguous().cpu()\n",
+        "        new_state_dict[b_key] = new_B.contiguous().cpu()\n",
+        "\n",
+        "        print(f\"   {base_key[-45:]:45} | {orig_rank:3}→{best_rank:3} | Acc {best_acc:5.2f}%\")\n",
+        "\n",
+        "    # === Prepare new metadata ===\n",
+        "    new_metadata = dict(original_metadata) if original_metadata else {}\n",
+        "    new_metadata.update({\n",
+        "        \"pruned_with\": f\"SVD Rank Reduction at {desired_accuracy}% accuracy\",\n",
+        "        \"original_file\": filename,\n",
+        "        \"pruning_date\": datetime.datetime.now().isoformat(),\n",
+        "        \"random_id\": str(random_suffix)\n",
+        "    })\n",
+        "\n",
+        "    # Make all tensors contiguous before saving\n",
+        "    for k, v in new_state_dict.items():\n",
+        "        if isinstance(v, torch.Tensor):\n",
+        "            new_state_dict[k] = v.contiguous()\n",
+        "\n",
+        "    # Save with metadata\n",
+        "    safetensors.torch.save_file(new_state_dict, output_path, metadata=new_metadata)\n",
+        "\n",
+        "    processed_files.append(output_path)\n",
+        "    mapping[filename] = letter\n",
+        "\n",
+        "    # === Create & Encrypt Metadata Text File ===\n",
+        "    meta_dir = f\"{base_dir}/metadata/{letter}\"\n",
+        "    os.makedirs(meta_dir, exist_ok=True)\n",
+        "    plain_meta_path = f\"{meta_dir}/{letter}_metadata.txt\"\n",
+        "    encrypted_meta_path = f\"{meta_dir}/{letter}_metadata.7z\"\n",
+        "\n",
+        "    # Write plain text first\n",
+        "    with open(plain_meta_path, \"w\", encoding=\"utf-8\") as f:\n",
+        "        f.write(f\"Original filename: {filename}\\n\")\n",
+        "        f.write(f\"Pruned filename : {output_name}\\n\")\n",
+        "        f.write(f\"Target Accuracy : {desired_accuracy}%\\n\")\n",
+        "        f.write(f\"Pruning Date    : {datetime.datetime.now()}\\n\")\n",
+        "        f.write(f\"Random ID       : {random_suffix}\\n\")\n",
+        "        f.write(\"\\n--- Original Metadata ---\\n\")\n",
+        "        if original_metadata:\n",
+        "            for k, v in original_metadata.items():\n",
+        "                f.write(f\"{k}: {v}\\n\")\n",
+        "        else:\n",
+        "            f.write(\"No original metadata found in safetensors file.\\n\")\n",
+        "\n",
+        "    # Encrypt with password 'banana'\n",
+        "    password = \"banana\"  #@param {type:'string'}\n",
+        "    !7z a -p{password} -mhe=on \"{encrypted_meta_path}\" \"{plain_meta_path}\" > /dev/null 2>&1\n",
+        "\n",
+        "    # Optional: Remove plain text after encryption (uncomment if you want only encrypted version)\n",
+        "    # os.remove(plain_meta_path)\n",
+        "\n",
+        "    print(f\"   → Saved as {output_name} (with preserved metadata)\")"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "dbt3RipEzPA5"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "cellView": "form",
+        "id": "249224b7"
+      },
+      "source": [
+        "#@markdown **Cell 6** - Save Processed LoRA to Google Drive\n",
+        "\n",
+        "#@markdown ---\n",
+        "#@markdown **Specify the target folder in your Google Drive (e.g., `/content/drive/MyDrive/MyLoRAs`)**\n",
+        "drive_save_path = \"/content/drive/MyDrive/Processed_LoRAs\" #@param {type:\"string\"}\n",
+        "\n",
+        "import shutil\n",
+        "import os\n",
+        "\n",
+        "# Ensure the target directory exists in Google Drive\n",
+        "os.makedirs(drive_save_path, exist_ok=True)\n",
+        "\n",
+        "print(f\"Saving processed LoRA files to: {drive_save_path}\")\n",
+        "\n",
+        "for processed_file in processed_files:\n",
+        "    file_name = os.path.basename(processed_file)\n",
+        "    target_file_path = os.path.join(drive_save_path, file_name)\n",
+        "    shutil.copy(processed_file, target_file_path)\n",
+        "    print(f\"✅ Copied '{file_name}' to '{target_file_path}'\")\n",
+        "\n",
+        "print(\"All processed LoRA files saved to Google Drive!\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}