Upload LoRa_Merge_Script.ipynb

LoRa_Merge_Script.ipynb

@@ -36,10 +36,10 @@
       ],
       "metadata": {
         "id": "CBVTifA_ZwdC",
-        "outputId": "8ce58389-8263-4016-8ebe-f61708ffef95",
         "colab": {
           "base_uri": "https://localhost:8080/"
-        }
+        },
+        "outputId": "8ce58389-8263-4016-8ebe-f61708ffef95"
       },
       "execution_count": 1,
       "outputs": [
@@ -55,27 +55,225 @@
     {
       "cell_type": "code",
       "source": [
+        "\n",
+        "import torch\n",
         "from safetensors.torch import load_file, save_file\n",
-        "_puff = load_file('/content/drive/MyDrive/Saved from Chrome/pffy3FLUX.safetensors')\n",
-        "puff = {}\n",
+        "import torch.nn as nn\n",
+        "from torch import linalg as LA\n",
+        "import os\n",
+        "import math\n",
+        "import random\n",
+        "import numpy as np\n",
+        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
         "\n",
-        "#alpha = 64\n",
-        "#rank = 64\n",
+        "# For pcnt = 30 , 'filter_and_save'  will keep all top 30 % values\n",
+        "#, and the lowest (negative) 30% values for each layer delta_W in this lora\n",
+        "# Then save the new filtered lora as a .safetensor file\n",
+        "def filter_and_save(_lora , savefile_name, new_rank , new_alpha, resolution):\n",
+        "    lora = {}\n",
+        "    count = 0\n",
+        "    for key in _lora:count = count + 1\n",
+        "    NUM_ITEMS = count\n",
+        "    count = 0\n",
+        "    thresh = resolution*0.000001 # 1e-6\n",
+        "    #-------#\n",
+        "    for key in _lora:\n",
+        "        if f'{key}'.find('alpha') > -1:\n",
+        "            lora[f'{key}'] = torch.tensor(new_alpha).to(device = device , dtype = torch.float32)\n",
+        "            count = count + 1\n",
+        "            print(f'{count} / {NUM_ITEMS}')\n",
+        "            continue\n",
+        "        #------#\n",
+        "        if not f'{key}'.find('lora_down') > -1: continue\n",
+        "        up = f'{key}'.replace('lora_down' , 'lora_up')\n",
+        "        down = f'{key}'\n",
+        "        #-------#\n",
+        "        delta_W = torch.matmul(_lora[up],_lora[down]).to(device = device , dtype=torch.float32)\n",
+        "        #---#\n",
+        "        N = delta_W.numel()\n",
+        "        y = delta_W.flatten().to(device = device , dtype=torch.float32)\n",
+        "        values,indices = torch.sort(y, descending = False) # smallest -> largest elements\n",
+        "        y = torch.zeros(y.shape).to(device = device , dtype=torch.float32)\n",
+        "        y[indices[values>thresh]] = 1\n",
+        "        y[indices[values<-thresh]] = 1\n",
+        "        y = y.unflatten(0,delta_W.shape).to(device = device , dtype=torch.float32)\n",
+        "        delta_W = torch.mul(delta_W,y).to(device = device , dtype=torch.float32)\n",
+        "        #------#\n",
+        "        tmp={}\n",
+        "        tmp['u'], tmp['s'], tmp['Vh'] = torch.svd(delta_W)\n",
+        "        tmp['u'] = tmp['u'][:,: new_rank]\n",
+        "        tmp['s'] = tmp['s'][: new_rank]\n",
+        "        #-------#\n",
+        "        tmp['u'] = torch.round(torch.matmul(tmp['u'], torch.diag(tmp['s'])),decimals=6)\n",
+        "        tmp['Vh'] = torch.round(tmp['Vh'].t()[: new_rank,:],decimals=6)\n",
+        "        #-------#\n",
+        "        for key in tmp:tmp[f'{key}'] = tmp[f'{key}'].contiguous()\n",
+        "        lora[up] = tmp['u'].to(device = device , dtype=torch.float32)\n",
+        "        lora[down] = tmp['Vh'].to(device = device , dtype=torch.float32)\n",
+        "        #-------#\n",
+        "        count  = count  + 2\n",
+        "        print(f'{count} / {NUM_ITEMS}')\n",
+        "    #-------#\n",
+        "    print(f'done!')\n",
+        "    print(f'casting params to fp16....')\n",
+        "    for key in _lora: lora[f'{key}'] = lora[f'{key}'].to(device = device , dtype=torch.float16)\n",
+        "    #-------#\n",
+        "    print(f'done!')\n",
+        "    print(f'saving {savefile_name}...')\n",
+        "    save_file(lora , f'{savefile_name}')\n",
+        "#--------#\n",
         "\n",
-        "# = > so scale = 1\n",
-        "#desired scale = 0.5\n",
-        "# so multiply matrices by 2 and set alpha to 32\n",
-        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
-        "for key in _puff:\n",
-        "  if f'{key}'.find('alpha')>-1:\n",
-        "    puff[f'{key}'] = torch.tensor(32).to(device=device , dtype = torch.float16)\n",
-        "    #print(puff[f'{key}'])\n",
-        "    continue\n",
-        "  puff[f'{key}'] = 2*_puff[f'{key}'].to(device=device , dtype = torch.float16)\n",
+        "def count_zeros(_lora, resolution):\n",
+        "    count = 0\n",
+        "    for key in _lora:count = count + 1\n",
+        "    NUM_ITEMS = count\n",
+        "    count = 0\n",
+        "    #-----#\n",
+        "    thresh = resolution*0.000001 # 1e-6\n",
         "\n",
-        "  #print(puff[f'{key}'].shape)\n",
+        "    print(f'at resolution = {resolution}e-6 :')\n",
+        "    for key in _lora:\n",
+        "        if f'{key}'.find('alpha') > -1:\n",
+        "            count = count + 1\n",
+        "            continue\n",
+        "        #------#\n",
+        "        if not f'{key}'.find('lora_down') > -1: continue\n",
+        "        up = f'{key}'.replace('lora_down' , 'lora_up')\n",
+        "        down = f'{key}'\n",
+        "        #-------#\n",
+        "        delta_W = torch.matmul(_lora[up],_lora[down]).to(device = device , dtype=torch.float32)\n",
+        "        N = delta_W.numel()\n",
+        "        y = delta_W.flatten().to(device = device , dtype=torch.float32)\n",
+        "        values,indices = torch.sort(y, descending = False) # smallest -> largest elements\n",
+        "        y = torch.ones(y.shape).to(device = device , dtype=torch.float32)\n",
+        "        y[indices[values>thresh]] = 0\n",
+        "        neg_pcnt  = round((100*torch.sum(y) / N).item(),2)\n",
+        "        y[indices[values<-thresh]] = 0\n",
+        "        count  = count  + 2\n",
+        "        pcnt  = round((100*torch.sum(y) / N).item(),2)\n",
+        "        neg_pcnt = round(neg_pcnt - pcnt,2) # remove zero % from neg_pcnt\n",
+        "        pos_pcnt = round(100- pcnt - neg_pcnt,2)\n",
+        "        print(f'at {count} / {NUM_ITEMS} : {pcnt} % zeros ,{pos_pcnt} % pos. , {neg_pcnt} % neg ')\n",
+        "    #------#\n",
+        "#-----#\n",
+        "\n",
+        "def merge_and_save(_lora1 , _lora2 , _lora3, savefile_name, new_rank , new_alpha, resolution):\n",
+        "    lora = {}\n",
+        "    count = 0\n",
+        "    for key in _lora1:count = count + 1\n",
+        "    NUM_ITEMS = count\n",
+        "    count = 0\n",
+        "    thresh = resolution*0.000001 # 1e-6\n",
+        "\n",
+        "    #-------#\n",
+        "    for key in _lora1:\n",
+        "        if f'{key}'.find('alpha') > -1:\n",
+        "            lora[f'{key}'] = torch.tensor(new_alpha).to(device = device , dtype = torch.float32)\n",
+        "            count = count + 1\n",
+        "            print(f'{count} / {NUM_ITEMS}')\n",
+        "            continue\n",
+        "        #------#\n",
+        "        #if count<462:\n",
+        "        #    count = count + 2\n",
+        "        #    continue\n",
+        "        if not f'{key}'.find('lora_down') > -1: continue\n",
+        "        up = f'{key}'.replace('lora_down' , 'lora_up')\n",
+        "        down = f'{key}'\n",
+        "        #-------#\n",
+        "\n",
+        "        # Setup\n",
+        "        delta_W = torch.matmul(_lora1[up]*0,_lora1[down]*0).to(device = device, dtype=torch.float32)\n",
+        "        tgt_shape = delta_W.shape\n",
+        "        N = delta_W.numel()\n",
+        "        delta_W = torch.zeros(N).to(device = device , dtype=torch.float32)\n",
+        "        #-----#\n",
+        "\n",
+        "        #Positives\n",
+        "        Y = torch.zeros(3,N).to(device = device , dtype=torch.float32)\n",
+        "        Y[0] = torch.matmul(_lora1[up],_lora1[down]).flatten().to(device = device , dtype=torch.float32)\n",
+        "        Y[1] = torch.matmul(_lora2[up],_lora2[down]).flatten().to(device = device , dtype=torch.float32)\n",
+        "        Y[2] = torch.matmul(_lora2[up],_lora2[down]).flatten().to(device = device , dtype=torch.float32)\n",
+        "        Y[torch.abs(Y)<thresh] = 0 #Trim\n",
+        "        Y = torch.round(Y,decimals=6).t()\n",
+        "        num_positives = torch.sum(Y>0,dim=1) + 0.1\n",
+        "        elect = torch.sum(Y<0,dim=1) + 0.1\n",
+        "        elect = (num_positives>=elect)\n",
+        "        Y[Y<0] = 0\n",
+        "        Y = torch.sum(Y, dim=1).to(device = device , dtype=torch.float32)\n",
+        "        delta_W[elect] = torch.round((Y[elect]/num_positives[elect]),decimals=6).to(device = device , dtype=torch.float32)\n",
+        "        #-----#\n",
+        "\n",
+        "        #Negatives\n",
+        "        Y = torch.zeros(3,N).to(device = device , dtype=torch.float32)\n",
+        "        Y[0] = torch.matmul(_lora1[up],_lora1[down]).flatten().to(device = device , dtype=torch.float32)\n",
+        "        Y[1] = torch.matmul(_lora2[up],_lora2[down]).flatten().to(device = device , dtype=torch.float32)\n",
+        "        Y[2] = torch.matmul(_lora2[up],_lora2[down]).flatten().to(device = device , dtype=torch.float32)\n",
+        "        Y[torch.abs(Y)<thresh] = 0 #Trim\n",
+        "        Y = torch.round(Y,decimals=6).t()\n",
+        "        num_negatives = torch.sum(Y<0,dim=1) + 0.1  # <-- to prevent divide by 0\n",
+        "        elect = torch.sum(Y>0,dim=1) + 0.1\n",
+        "        elect = (elect<num_negatives)\n",
+        "        Y[Y>0] = 0\n",
+        "        Y = torch.sum(Y, dim=1).to(device = device , dtype=torch.float32)\n",
+        "        delta_W[elect] = torch.round(Y[elect]/num_positives[elect],decimals=6).to(device = device , dtype=torch.float32)\n",
+        "        #----#\n",
+        "\n",
+        "        # Free up memory prior to SVD\n",
+        "        delta_W = delta_W.unflatten(0,tgt_shape).to(device = device , dtype=torch.float32)\n",
+        "        delta_W = delta_W.clone().detach()\n",
+        "        Y = {}\n",
+        "        num_positives = {}\n",
+        "        num_negatives = {}\n",
+        "        elect = {}\n",
+        "        #-----#\n",
+        "\n",
+        "        # Run SVD (Single Value Decomposition)\n",
+        "        #to get the new lora_up and lora_down for delta_W\n",
+        "        tmp={}\n",
+        "        tmp['u'], tmp['s'], tmp['Vh'] = torch.svd(delta_W)\n",
+        "        tmp['u'] = tmp['u'][:,: new_rank]\n",
+        "        tmp['s'] = tmp['s'][: new_rank]\n",
+        "        tmp['u'] = torch.matmul(tmp['u'], torch.diag(tmp['s']))\n",
+        "        tmp['Vh'] = tmp['Vh'].t()[: new_rank,:]\n",
+        "        for key in tmp:tmp[f'{key}'] = tmp[f'{key}'].contiguous()\n",
+        "        lora[up] = torch.round(tmp['u'],decimals=6).to(device = device , dtype=torch.float32)\n",
+        "        lora[down] = torch.round(tmp['Vh'],decimals=6).to(device = device , dtype=torch.float32)\n",
+        "        #-------#\n",
         "\n",
-        "save_file(puff, 'buff.safetensors')"
+        "        count  = count  + 2\n",
+        "        print(f'{count} / {NUM_ITEMS}')\n",
+        "        #----#\n",
+        "    #--------#\n",
+        "    print(f'done!')\n",
+        "    print(f'casting params to fp16....')\n",
+        "    for key in lora: lora[f'{key}'] = lora[f'{key}'].to(device = device , dtype=torch.float16)\n",
+        "    #-------#\n",
+        "    print(f'done!')\n",
+        "    print(f'saving {savefile_name}...')\n",
+        "    save_file(lora , f'{savefile_name}')\n",
+        "#------#\n",
+        "\n",
+        "new_rank = 32\n",
+        "new_alpha = math.floor(new_rank/2)\n",
+        "resolution = 200\n",
+        "name = 'yeero_euro_puff'\n",
+        "yeero = load_file('/kaggle/input/flux-loras/yeero_100_r32_16alpha.safetensors')\n",
+        "euro = load_file('/kaggle/input/flux-loras/euro_100_r32_16alpha.safetensors')\n",
+        "puff = load_file('/kaggle/input/flux-loras/puff_200_r32_16alpha.safetensors')\n",
+        "savefile_name = f'{name}_{resolution}_r{new_rank}_a{new_alpha}.safetensors'\n",
+        "\n",
+        "#tgt = load_file(f'/kaggle/input/flux-loras/{name}_{resolution}_r32_16alpha.safetensors')\n",
+        "for key in yeero:\n",
+        "    yeero[f'{key}'] = yeero[f'{key}'].to(device = device , dtype = torch.float32)\n",
+        "    euro[f'{key}'] = euro[f'{key}'].to(device = device , dtype = torch.float32)\n",
+        "    puff[f'{key}'] = puff[f'{key}'].to(device = device , dtype = torch.float32)\n",
+        "#-----#\n",
+        "print(f'for {name}.safetensors at scale = (rank/alpha) = 0.5')\n",
+        "merge_and_save(yeero , euro , puff, savefile_name, new_rank , new_alpha, resolution)\n",
+        "\n",
+        "\n",
+        "#Yeero + Scale + Puff\n",
+        "#filter_and_save(tgt , f'{name}_{resolution}_r{new_rank}_{new_alpha}alpha.safetensors' , new_rank , new_alpha, resolution)\n"
       ],
       "metadata": {
         "id": "SKYzFxehkfG8"
@@ -180,10 +378,10 @@
       "metadata": {
         "id": "1oxeJYHRqxQC",
         "collapsed": true,
-        "outputId": "12e3a407-f9d1-403e-949b-31330be59577",
         "colab": {
           "base_uri": "https://localhost:8080/"
-        }
+        },
+        "outputId": "12e3a407-f9d1-403e-949b-31330be59577"
       },
       "execution_count": 12,
       "outputs": [
@@ -1203,11 +1401,11 @@
         "#print(torch.matmul(tgt[f'{up}'],tgt[f'{down}']).shape)\n"
       ],
       "metadata": {
-        "id": "GoDfgENYaWD7",
-        "outputId": "9336ae1a-6244-4e76-f291-82cda4482831",
         "colab": {
           "base_uri": "https://localhost:8080/"
-        }
+        },
+        "id": "GoDfgENYaWD7",
+        "outputId": "9336ae1a-6244-4e76-f291-82cda4482831"
       },
       "execution_count": 17,
       "outputs": [
@@ -1230,11 +1428,11 @@
         "  print(oily[f'{key}'].shape)"
       ],
       "metadata": {
-        "id": "xQhVLouEfmGE",
-        "outputId": "662176b3-480d-48eb-f5db-97ec71b5e970",
         "colab": {
           "base_uri": "https://localhost:8080/"
-        }
+        },
+        "id": "xQhVLouEfmGE",
+        "outputId": "662176b3-480d-48eb-f5db-97ec71b5e970"
       },
       "execution_count": 18,
       "outputs": [