Upload sd_token_similarity_calculator.ipynb

sd_token_similarity_calculator.ipynb

@@ -274,19 +274,42 @@
         "id": "IUCuV9RtQpBn"
       }
     },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title ⚡💾 Save results as .db file\n",
+        "import shelve\n",
+        "d = shelve.open('tokens_most_similiar_to_' + name_A.replace('</w>','').strip())\n",
+        "#NUM TOKENS == 49407\n",
+        "for index in range(NUM_TOKENS):\n",
+        "  #print(d[f'{index}']) #<-----Use this to read values from the .db file\n",
+        "  d[f'{index}']= vocab[indices[index].item()] #<---- write values to .db file\n",
+        "#----#\n",
+        "d.close() #close the file\n",
+        "# See this link for additional stuff to do with shelve: https://docs.python.org/3/library/shelve.html"
+      ],
+      "metadata": {
+        "id": "qj888fPEbX8K"
+      },
+      "execution_count": 15,
+      "outputs": []
+    },
     {
       "cell_type": "code",
       "source": [
         "# @title 🪐🖼️ -> 📝 Token-Sampling Image interrogator\n",
-        "\n",
+        "VOCAB_FILENAME = 'tokens_most_similiar_to_girl' #This vocab has been ordered where lowest index has the highest similarity to the reference vector \"girl</w>\". Feel free to create your own .db around a target token in above cells.\n",
+        "#-----#\n",
+        "import shelve\n",
+        "db_vocab = shelve.open(VOCAB_FILENAME)\n",
         "# @markdown # What do you want to to mimic?\n",
-        "use = '🖼️image_encoding from image' # @param ['📝text_encoding from prompt', '🖼️image_encoding from image']\n",
+        "use = '📝text_encoding from prompt' # @param ['📝text_encoding from prompt', '🖼️image_encoding from image']\n",
         "# @markdown --------------------------\n",
         "use_token_padding = True # param {type:\"boolean\"} <---- Enabled by default\n",
         "prompt = \"photo of a banana\" # @param {\"type\":\"string\",\"placeholder\":\"Write a prompt\"}\n",
-        "\n",
+        "#-----#\n",
         "prompt_A = prompt\n",
-        "\n",
+        "#-----#\n",
         "from google.colab import files\n",
         "def upload_files():\n",
         "  from google.colab import files\n",
@@ -297,17 +320,12 @@
         "#Get image\n",
         "# You can use \"http://images.cocodataset.org/val2017/000000039769.jpg\" for testing\n",
         "image_url = \"http://images.cocodataset.org/val2017/000000039769.jpg\" # @param {\"type\":\"string\",\"placeholder\":\"leave empty for local upload (scroll down to see it)\"}\n",
-        "\n",
-        "\n",
         "colab_image_path = \"\" # @param {\"type\":\"string\",\"placeholder\": \"eval. as '/content/sd_tokens/' + **your input**\"}\n",
-        "\n",
         "# @markdown --------------------------\n",
         "from PIL import Image\n",
         "import requests\n",
         "image_A = \"\"\n",
-        "\n",
         "#----#\n",
-        "\n",
         "if(use == '🖼️image_encoding from image'):\n",
         "  if image_url == \"\":\n",
         "    import cv2\n",
@@ -323,14 +341,12 @@
         "  else:\n",
         "    image_A = Image.open(requests.get(image_url, stream=True).raw)\n",
         "#------#\n",
-        "\n",
         "from transformers import AutoTokenizer\n",
         "tokenizer = AutoTokenizer.from_pretrained(\"openai/clip-vit-large-patch14\", clean_up_tokenization_spaces = False)\n",
         "from transformers import  CLIPProcessor, CLIPModel\n",
         "processor = CLIPProcessor.from_pretrained(\"openai/clip-vit-large-patch14\" , clean_up_tokenization_spaces = True)\n",
         "model = CLIPModel.from_pretrained(\"openai/clip-vit-large-patch14\")\n",
-        "\n",
-        "\n",
+        "#-----#\n",
         "if(use == '🖼️image_encoding from image'):\n",
         "  # Get image features\n",
         "  inputs = processor(images=image_A, return_tensors=\"pt\")\n",
@@ -338,34 +354,27 @@
         "  image_features = image_features / image_features.norm(p=2, dim=-1, keepdim=True)\n",
         "  name_A = \"the image\"\n",
         "#-----#\n",
-        "\n",
-        "\n",
         "if(use == '📝text_encoding from prompt'):\n",
         "  # Get text features\n",
         "  inputs = tokenizer(text = prompt, padding=True, return_tensors=\"pt\")\n",
         "  text_features_A = model.get_text_features(**inputs)\n",
         "  name_A = prompt\n",
         "#-----#\n",
-        "\n",
-        "\n",
         "# @markdown # The output...\n",
         "must_start_with = \"\" # @param {\"type\":\"string\",\"placeholder\":\"write a text\"}\n",
         "must_contain = \"banana \" # @param {\"type\":\"string\",\"placeholder\":\"write a text\"}\n",
         "must_end_with = \"\" # @param {\"type\":\"string\",\"placeholder\":\"write a text\"}\n",
         "token_B = must_contain\n",
-        "\n",
         "# @markdown -----\n",
-        "\n",
         "# @markdown # Use a range of tokens from the vocab.json (slow method)\n",
-        "start_search_at_ID = 27700 # @param {type:\"slider\", min:0, max: 49407, step:100}\n",
+        "start_search_at_index = 1700 # @param {type:\"slider\", min:0, max: 49407, step:100}\n",
+        "# @markdown The lower the start_index, the more similiar the sampled tokens will be to the reference token \"girl\\</w>\"\n",
+        "start_search_at_ID = start_search_at_index\n",
         "search_range = 100 # @param {type:\"slider\", min:100, max: 2000, step:0}\n",
         "restrictions = 'None' # @param [\"None\", \"Suffix only\", \"Prefix only\"]\n",
-        "\n",
         "#markdown Limit char size of included token <----- Disabled\n",
         "min_char_size = 0 #param {type:\"slider\", min:0, max: 20, step:1}\n",
         "char_range = 50 #param {type:\"slider\", min:0, max: 20, step:1}\n",
-        "\n",
-        "\n",
         "# markdown # ...or paste prompt items\n",
         "# markdown Format must be {item1|item2|...}. You can aquire prompt items using the Randomizer in the fusion gen: https://perchance.org/fusion-ai-image-generator\n",
         "_enable = False # param {\"type\":\"boolean\"}\n",
@@ -373,26 +382,21 @@
         "#-----#\n",
         "name_B = must_contain\n",
         "#-----#\n",
-        "\n",
         "START = start_search_at_ID\n",
         "RANGE =  min(search_range , 49407 - start_search_at_ID)\n",
-        "\n",
+        "#-----#\n",
         "dots = torch.zeros(RANGE)\n",
         "is_BC = torch.zeros(RANGE)\n",
-        "\n",
         "import re\n",
-        "\n",
+        "#-----#\n",
         "for index in range(RANGE):\n",
         "  id_C = START + index\n",
-        "  name_C = vocab[id_C]\n",
+        "  name_C = db_vocab[f'{id_C}']\n",
         "  is_Prefix = 0\n",
-        "\n",
-        "\n",
         "  #Skip if non-AZ characters are found\n",
         "  if re.search(\"\\W/g\" , name_C.replace('</w>', '')):\n",
         "    continue\n",
-        "\n",
-        "\n",
+        "  #-----#\n",
         "  # Decide if we should process prefix/suffix tokens\n",
         "  if name_C.find('</w>')<=-1:\n",
         "    is_Prefix = 1\n",
@@ -402,7 +406,6 @@
         "    if restrictions == \"Prefix only\":\n",
         "      continue\n",
         "  #-----#\n",
-        "\n",
         "  # Decide if char-size is within range\n",
         "  if len(name_C) < min_char_size:\n",
         "    continue\n",
@@ -413,7 +416,6 @@
         "  if is_Prefix>0:\n",
         "    name_CB = must_start_with + ' ' + name_C.strip() + '-' + name_B.strip() + ' ' + must_end_with\n",
         "  #-----#\n",
-        "\n",
         "  if(use == '🖼️image_encoding from image'):\n",
         "    ids_CB = processor.tokenizer(text=name_CB, padding=use_token_padding, return_tensors=\"pt\")\n",
         "    text_features = model.get_text_features(**ids_CB)\n",
@@ -422,16 +424,12 @@
         "    torch.matmul(text_features, image_features.t()) * logit_scale\n",
         "    sim_CB = torch.nn.functional.cosine_similarity(text_features, image_features) * logit_scale\n",
         "  #-----#\n",
-        "\n",
         "  if(use == '📝text_encoding from prompt'):\n",
         "    ids_CB = processor.tokenizer(text=name_CB, padding=use_token_padding, return_tensors=\"pt\")\n",
         "    text_features = model.get_text_features(**ids_CB)\n",
         "    text_features = text_features / text_features.norm(p=2, dim=-1, keepdim=True)\n",
         "    sim_CB = torch.nn.functional.cosine_similarity(text_features, text_features_A)\n",
         "  #-----#\n",
-        "\n",
-        "\n",
-        "\n",
         "  #-----#\n",
         "  if restrictions == \"Prefix only\":\n",
         "    result = sim_CB\n",
@@ -439,7 +437,6 @@
         "    dots[index] = result\n",
         "    continue\n",
         "  #-----#\n",
-        "\n",
         "  if(use == '🖼️image_encoding from image'):\n",
         "    name_BC = must_start_with + name_B + name_C + must_end_with\n",
         "    ids_BC = processor.tokenizer(text=name_BC, padding=use_token_padding, return_tensors=\"pt\")\n",
@@ -449,7 +446,6 @@
         "    torch.matmul(text_features, image_features.t()) * logit_scale\n",
         "    sim_BC = torch.nn.functional.cosine_similarity(text_features, image_features) * logit_scale\n",
         "  #-----#\n",
-        "\n",
         "  if(use == '📝text_encoding from prompt'):\n",
         "    name_BC = must_start_with + name_B + name_C + must_end_with\n",
         "    ids_BC = processor.tokenizer(text=name_BC, padding=use_token_padding, return_tensors=\"pt\")\n",
@@ -457,20 +453,16 @@
         "    text_features = text_features / text_features.norm(p=2, dim=-1, keepdim=True)\n",
         "    sim_BC = torch.nn.functional.cosine_similarity(text_features, text_features_A)\n",
         "  #-----#\n",
-        "\n",
         "  result = sim_CB\n",
         "  if(sim_BC > sim_CB):\n",
         "    is_BC[index] = 1\n",
         "    result = sim_BC\n",
-        "\n",
+        "  #-----#\n",
         "  #result = absolute_value(result.item())\n",
         "  result = result.item()\n",
         "  dots[index] = result\n",
         "#----#\n",
-        "\n",
         "sorted, indices = torch.sort(dots,dim=0 , descending=True)\n",
-        "\n",
-        "\n",
         "# @markdown ----------\n",
         "# @markdown # Print options\n",
         "list_size = 100 # @param {type:'number'}\n",
@@ -478,11 +470,10 @@
         "print_Similarity = True # @param {type:\"boolean\"}\n",
         "print_Name = True # @param {type:\"boolean\"}\n",
         "print_Divider = True # @param {type:\"boolean\"}\n",
-        "\n",
-        "\n",
+        "#----#\n",
         "if (print_Divider):\n",
         "  print('//---//')\n",
-        "\n",
+        "#----#\n",
         "print('')\n",
         "print(f'These token pairings within the range ID = {START} to ID = {START + RANGE} most closely match the text_encoding for {prompt_A} : ')\n",
         "print('')\n",
@@ -499,7 +490,7 @@
         "#----#\n",
         "for index in range(min(list_size,RANGE)):\n",
         "  id = START + indices[index].item()\n",
-        "  name = vocab[id]\n",
+        "  name = db_vocab[f'{id}']\n",
         "  #-----#\n",
         "  if (name.find('</w>')<=-1):\n",
         "    name = name + '-'\n",
@@ -511,7 +502,7 @@
         "    aheads = aheads + name + \"|\"\n",
         "  #----#\n",
         "  sim = sorted[index].item()\n",
-        "\n",
+        "  #----#\n",
         "  if(is_BC[index]>0):\n",
         "    if sim>max_sim_ahead:\n",
         "      max_sim_ahead = sim\n",
@@ -520,7 +511,6 @@
         "    if sim>max_sim_trail:\n",
         "      max_sim_trail = sim\n",
         "      max_name_trail = name\n",
-        "\n",
         "#------#\n",
         "trails = (trails + \"&&&&\").replace(\"|&&&&\", \"}\").replace(\"</w>\", \" \").replace(\"{&&&&\", \"\")\n",
         "aheads = (aheads + \"&&&&\").replace(\"|&&&&\", \"}\").replace(\"</w>\", \" \").replace(\"{&&&&\", \"\")\n",
@@ -537,10 +527,9 @@
         "#-----#\n",
         "#STEP 2\n",
         "import random\n",
-        "\n",
         "names = {}\n",
-        "\n",
-        "NUM_PERMUTATIONS = 4 # 0 1 2 3\n",
+        "NUM_PERMUTATIONS = 4\n",
+        "#-----#\n",
         "dots = torch.zeros(NUM_PERMUTATIONS)\n",
         "for index in range(NUM_PERMUTATIONS):\n",
         "  name = must_start_with\n",
@@ -551,7 +540,7 @@
         "  name = name + must_end_with\n",
         "  #----#\n",
         "  ids = processor.tokenizer(text=name, padding=use_token_padding, return_tensors=\"pt\")\n",
-        "\n",
+        "  #----#\n",
         "  if(use == '🖼️image_encoding from image'):\n",
         "    text_features = model.get_text_features(**ids)\n",
         "    text_features = text_features / text_features.norm(p=2, dim=-1, keepdim=True)\n",
@@ -559,26 +548,22 @@
         "    torch.matmul(text_features, image_features.t()) * logit_scale\n",
         "    sim = torch.nn.functional.cosine_similarity(text_features, image_features) * logit_scale\n",
         "  #-----#\n",
-        "\n",
         "  if(use == '📝text_encoding from prompt'):\n",
         "    text_features = model.get_text_features(**ids)\n",
         "    text_features = text_features / text_features.norm(p=2, dim=-1, keepdim=True)\n",
         "    sim = torch.nn.functional.cosine_similarity(text_features, text_features_A)\n",
         "  #-----#\n",
-        "\n",
-        "\n",
         "  dots[index] = sim\n",
         "  names[index] = name\n",
-        "\n",
-        "\n",
         "#------#\n",
-        "\n",
         "sorted, indices = torch.sort(dots,dim=0 , descending=True)\n",
-        "\n",
+        "#------#\n",
         "for index in range(NUM_PERMUTATIONS):\n",
         "  print(names[indices[index].item()])\n",
         "  print(f'similiarity = {round(sorted[index].item(),2)} %')\n",
-        "  print('------')"
+        "  print('------')\n",
+        "#------#\n",
+        "db_vocab.close() #close the file"
       ],
       "metadata": {
         "collapsed": true,
@@ -620,7 +605,8 @@
       ],
       "metadata": {
         "id": "QQOjh5BvnG8M",
-        "collapsed": true
+        "collapsed": true,
+        "cellView": "form"
       },
       "execution_count": null,
       "outputs": []