Upload sd_token_similarity_calculator.ipynb

sd_token_similarity_calculator.ipynb

@@ -118,8 +118,7 @@
       ],
       "metadata": {
         "id": "Ch9puvwKH1s3",
-        "collapsed": true,
-        "cellView": "form"
+        "collapsed": true
       },
       "execution_count": null,
       "outputs": []
@@ -133,7 +132,7 @@
         "tokenizer = AutoTokenizer.from_pretrained(\"openai/clip-vit-large-patch14\", clean_up_tokenization_spaces = False)\n",
         "\n",
         "# @markdown Write name of token to match against\n",
-        "token_name = \"banana\" # @param {type:'string',\"placeholder\":\"leave empty for random value token\"}\n",
+        "token_name = \"dogs\" # @param {type:'string',\"placeholder\":\"leave empty for random value token\"}\n",
         "\n",
         "prompt = token_name\n",
         "# @markdown (optional) Mix the token with something else\n",
@@ -298,8 +297,10 @@
       "source": [
         "# @title ⚡+🖼️ -> 📝 Token-Sampling Image interrogator\n",
         "#-----#\n",
+        "NUM_TOKENS = 49407\n",
         "import shelve\n",
         "db_vocab = shelve.open(VOCAB_FILENAME)\n",
+        "print(f'using the tokens found in {VOCAB_FILENAME}.db as the vocab')\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",
         "# @markdown --------------------------\n",
@@ -317,7 +318,7 @@
         "  return list(uploaded.keys())\n",
         "#Get image\n",
         "# You can use \"http://images.cocodataset.org/val2017/000000039769.jpg\" for testing\n",
-        "image_url = \"\" # @param {\"type\":\"string\",\"placeholder\":\"leave empty for local upload (scroll down to see it)\"}\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",
         "colab_image_path = \"\" # @param {\"type\":\"string\",\"placeholder\": \"eval. as '/content/sd_tokens/' + **your input**\"}\n",
         "# @markdown --------------------------\n",
         "from PIL import Image\n",
@@ -360,13 +361,12 @@
         "#-----#\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_contain = \" pet \" # @param {\"type\":\"string\",\"placeholder\":\"write a text\"}\n",
         "must_end_with = \"\" # @param {\"type\":\"string\",\"placeholder\":\"write a text\"}\n",
-        "token_B = must_contain\n",
         "# @markdown -----\n",
         "# @markdown # Use a range of tokens from the vocab.json (slow method)\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 target token assigned in the '⚡ Get similiar tokens' cell\"\n",
+        "# @markdown The lower the start_index, the more similiar the sampled tokens will be to the target token assigned in the '⚡ Get similiar tokens' cell\". If the cell was not run, then it will use tokens ordered by similarity to the \"girl\\</w>\" token\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",
@@ -378,186 +378,238 @@
         "_enable = False # param {\"type\":\"boolean\"}\n",
         "prompt_items = \"\" # param {\"type\":\"string\",\"placeholder\":\"{item1|item2|...}\"}\n",
         "#-----#\n",
-        "name_B = must_contain\n",
         "#-----#\n",
         "START = start_search_at_ID\n",
-        "RANGE =  min(search_range , 49407 - start_search_at_ID)\n",
+        "RANGE =  min(search_range , max(1,NUM_TOKENS - start_search_at_ID))\n",
+        "#-----#\n",
+        "import math, random\n",
+        "CHUNK = math.floor(NUM_TOKENS/(RANGE*100))\n",
+        "\n",
+        "ITERS = 3\n",
+        "#-----#\n",
+        "#LOOP START\n",
+        "#-----#\n",
+        "\n",
+        "results_sim = torch.zeros(ITERS+1)\n",
+        "results_name = {}\n",
+        "\n",
+        "# Check if original solution is best\n",
+        "best_sim = 0\n",
+        "name = must_start_with + must_contain + must_end_with\n",
+        "ids = processor.tokenizer(text=name, padding=use_token_padding, return_tensors=\"pt\")\n",
+        "text_features = model.get_text_features(**ids)\n",
+        "text_features = text_features / text_features.norm(p=2, dim=-1, keepdim=True)\n",
+        "#------#\n",
+        "if(use == '🖼️image_encoding from image'):\n",
+        "  logit_scale = model.logit_scale.exp()\n",
+        "  torch.matmul(text_features, image_features.t()) * logit_scale\n",
+        "  sim = torch.nn.functional.cosine_similarity(text_features, image_features) * logit_scale\n",
         "#-----#\n",
-        "dots = torch.zeros(RANGE)\n",
-        "is_BC = torch.zeros(RANGE)\n",
-        "import re\n",
+        "if(use == '📝text_encoding from prompt'):\n",
+        "  sim = torch.nn.functional.cosine_similarity(text_features, text_features_A)\n",
         "#-----#\n",
-        "for index in range(RANGE):\n",
-        "  id_C = START + index\n",
-        "  name_C = db_vocab[f'{id_C}']\n",
-        "  is_Prefix = 0\n",
-        "  #Skip if non-AZ characters are found\n",
-        "  if re.search(\"\\W/g\" , name_C.replace('</w>', '')):\n",
-        "    continue\n",
+        "best_sim = sim\n",
+        "name_B = must_contain\n",
+        "#-----#\n",
+        "for iter in range(ITERS):\n",
+        "  dots = torch.zeros(RANGE)\n",
+        "  is_trail = torch.zeros(RANGE)\n",
+        "  import re\n",
         "  #-----#\n",
-        "  # Decide if we should process prefix/suffix tokens\n",
-        "  if name_C.find('</w>')<=-1:\n",
-        "    is_Prefix = 1\n",
-        "    if restrictions != \"Prefix only\":\n",
+        "\n",
+        "  _start = START + iter*CHUNK  + iter*random.randint(1,CHUNK)\n",
+        "  results_name[iter] = name_B\n",
+        "  results_sim[iter] = best_sim\n",
+        "\n",
+        "  for index in range(RANGE):\n",
+        "    id_C = min(_start + index, NUM_TOKENS)\n",
+        "    name_C = db_vocab[f'{id_C}']\n",
+        "    is_Prefix = 0\n",
+        "    #Skip if non-AZ characters are found\n",
+        "    #???\n",
+        "    #-----#\n",
+        "    # Decide if we should process prefix/suffix tokens\n",
+        "    if name_C.find('</w>')<=-1:\n",
+        "      is_Prefix = 1\n",
+        "      if restrictions != \"Prefix only\":\n",
+        "        continue\n",
+        "    else:\n",
+        "      if restrictions == \"Prefix only\":\n",
+        "        continue\n",
+        "    #-----#\n",
+        "    # Decide if char-size is within range\n",
+        "    if len(name_C) < min_char_size:\n",
         "      continue\n",
-        "  else:\n",
+        "    if len(name_C) > min_char_size + char_range:\n",
+        "      continue\n",
+        "    #-----#\n",
+        "    name_CB = must_start_with + name_C + name_B + must_end_with\n",
+        "    if is_Prefix>0:\n",
+        "      name_CB = must_start_with + ' ' + name_C + '-' + name_B + ' ' + must_end_with\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",
+        "      text_features = text_features / text_features.norm(p=2, dim=-1, keepdim=True)\n",
+        "      logit_scale = model.logit_scale.exp()\n",
+        "      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",
+        "    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",
         "    if restrictions == \"Prefix only\":\n",
+        "      result = sim_CB\n",
+        "      result = result.item()\n",
+        "      dots[index] = result\n",
         "      continue\n",
-        "  #-----#\n",
-        "  # Decide if char-size is within range\n",
-        "  if len(name_C) < min_char_size:\n",
-        "    continue\n",
-        "  if len(name_C) > min_char_size + char_range:\n",
-        "    continue\n",
-        "  #-----#\n",
-        "  name_CB = must_start_with + name_C + name_B + must_end_with\n",
-        "  if is_Prefix>0:\n",
-        "    name_CB = must_start_with + ' ' + name_C.strip() + '-' + name_B.strip() + ' ' + must_end_with\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",
-        "    text_features = text_features / text_features.norm(p=2, dim=-1, keepdim=True)\n",
-        "    logit_scale = model.logit_scale.exp()\n",
-        "    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",
-        "  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",
-        "  if restrictions == \"Prefix only\":\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",
+        "      text_features = model.get_text_features(**ids_BC)\n",
+        "      text_features = text_features / text_features.norm(p=2, dim=-1, keepdim=True)\n",
+        "      logit_scale = model.logit_scale.exp()\n",
+        "      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",
+        "    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",
+        "      text_features = model.get_text_features(**ids_BC)\n",
+        "      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",
         "    result = sim_CB\n",
+        "    if(sim_BC > sim_CB):\n",
+        "      is_trail[index] = 1\n",
+        "      result = sim_BC\n",
+        "    #-----#\n",
+        "    #result = absolute_value(result.item())\n",
         "    result = result.item()\n",
         "    dots[index] = result\n",
-        "    continue\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",
-        "    text_features = model.get_text_features(**ids_BC)\n",
-        "    text_features = text_features / text_features.norm(p=2, dim=-1, keepdim=True)\n",
-        "    logit_scale = model.logit_scale.exp()\n",
-        "    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",
-        "  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",
-        "    text_features = model.get_text_features(**ids_BC)\n",
-        "    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",
-        "  result = sim_CB\n",
-        "  if(sim_BC > sim_CB):\n",
-        "    is_BC[index] = 1\n",
-        "    result = sim_BC\n",
-        "  #-----#\n",
-        "  #result = absolute_value(result.item())\n",
-        "  result = result.item()\n",
-        "  dots[index] = result\n",
-        "#----#\n",
-        "sorted, indices = torch.sort(dots,dim=0 , descending=True)\n",
-        "# @markdown ----------\n",
-        "# @markdown # Print options\n",
-        "list_size = 100 # @param {type:'number'}\n",
-        "print_ID = False # @param {type:\"boolean\"}\n",
-        "print_Similarity = True # @param {type:\"boolean\"}\n",
-        "print_Name = True # @param {type:\"boolean\"}\n",
-        "print_Divider = True # @param {type:\"boolean\"}\n",
-        "#----#\n",
-        "if (print_Divider):\n",
-        "  print('//---//')\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",
-        "#----#\n",
-        "aheads = \"{\"\n",
-        "trails = \"{\"\n",
-        "tmp = \"\"\n",
-        "#----#\n",
-        "max_sim_ahead = 0\n",
-        "max_sim_trail = 0\n",
-        "sim = 0\n",
-        "max_name_ahead = ''\n",
-        "max_name_trail = ''\n",
-        "#----#\n",
-        "for index in range(min(list_size,RANGE)):\n",
-        "  id = START + indices[index].item()\n",
-        "  name = db_vocab[f'{id}']\n",
-        "  #-----#\n",
-        "  if (name.find('</w>')<=-1):\n",
-        "    name = name + '-'\n",
-        "  else:\n",
-        "    name = name.replace('</w>', ' ')\n",
-        "  if(is_BC[index]>0):\n",
-        "    trails = trails + name + \"|\"\n",
-        "  else:\n",
-        "    aheads = aheads + name + \"|\"\n",
         "  #----#\n",
-        "  sim = sorted[index].item()\n",
+        "  sorted, indices = torch.sort(dots,dim=0 , descending=True)\n",
+        "  # @markdown ----------\n",
+        "  # @markdown # Print options\n",
+        "  list_size = 100 # @param {type:'number'}\n",
+        "  print_ID = False # @param {type:\"boolean\"}\n",
+        "  print_Similarity = True # @param {type:\"boolean\"}\n",
+        "  print_Name = True # @param {type:\"boolean\"}\n",
+        "  print_Divider = True # @param {type:\"boolean\"}\n",
         "  #----#\n",
-        "  if(is_BC[index]>0):\n",
-        "    if sim>max_sim_ahead:\n",
-        "      max_sim_ahead = sim\n",
-        "      max_name_ahead = name\n",
-        "  else:\n",
-        "    if sim>max_sim_trail:\n",
-        "      max_sim_trail = sim\n",
-        "      max_name_trail = name\n",
-        "#------#\n",
-        "trails = (trails + \"&&&&\").replace(\"|&&&&\", \"}\").replace(\"</w>\", \" \").replace(\"{&&&&\", \"\")\n",
-        "aheads = (aheads + \"&&&&\").replace(\"|&&&&\", \"}\").replace(\"</w>\", \" \").replace(\"{&&&&\", \"\")\n",
-        "max_sim_ahead=max_sim_ahead\n",
-        "max_sim_ahead=max_sim_trail\n",
-        "#-----#\n",
-        "print(f\"place these items ahead of prompt :  {aheads}\")\n",
-        "print(\"\")\n",
-        "print(f\"place these items behind the prompt : {trails}\")\n",
-        "print(\"\")\n",
-        "print(f\"max_similarity = {max_sim_ahead} % when using '{max_name_ahead + must_contain}' \")\n",
-        "print(\"\")\n",
-        "print(f\"max_similarity = {max_sim_trail} % when using '{must_contain  + max_name_trail}' \")\n",
-        "#-----#\n",
-        "#STEP 2\n",
-        "import random\n",
-        "names = {}\n",
-        "NUM_PERMUTATIONS = 4\n",
-        "#-----#\n",
-        "dots = torch.zeros(NUM_PERMUTATIONS)\n",
-        "for index in range(NUM_PERMUTATIONS):\n",
-        "  name = must_start_with\n",
-        "  if index == 0 : name = name + must_contain\n",
-        "  if index == 1 : name = name + max_name_ahead + must_contain\n",
-        "  if index == 2 : name = name + must_contain + max_name_trail\n",
-        "  if index == 3 : name = name + max_name_ahead + must_contain + max_name_trail\n",
-        "  name = name + must_end_with\n",
-        "  #----#\n",
-        "  ids = processor.tokenizer(text=name, padding=use_token_padding, return_tensors=\"pt\")\n",
+        "  if (print_Divider):\n",
+        "    print('//---//')\n",
         "  #----#\n",
+        "  print('')\n",
+        "\n",
+        "  used_reference = f'the text_encoding for {prompt_A}'\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",
-        "    logit_scale = model.logit_scale.exp()\n",
-        "    torch.matmul(text_features, image_features.t()) * logit_scale\n",
-        "    sim = torch.nn.functional.cosine_similarity(text_features, image_features) * logit_scale\n",
+        "    used_reference = 'the image input'\n",
+        "  print(f'These token pairings within the range ID = {START} to ID = {START + RANGE} most closely match {used_reference}: ')\n",
+        "  print('')\n",
+        "  #----#\n",
+        "  aheads = \"{\"\n",
+        "  trails = \"{\"\n",
+        "  tmp = \"\"\n",
+        "  #----#\n",
+        "  max_sim_ahead = 0\n",
+        "  max_sim_trail = 0\n",
+        "  sim = 0\n",
+        "  max_name_ahead = ''\n",
+        "  max_name_trail = ''\n",
+        "  #----#\n",
+        "  for index in range(min(list_size,RANGE)):\n",
+        "    id = START + indices[index].item()\n",
+        "    name = db_vocab[f'{id}']\n",
+        "    #-----#\n",
+        "    if (name.find('</w>')<=-1):\n",
+        "      name = name + '-'\n",
+        "    if(is_trail[index]>0):\n",
+        "      trails = trails + name + \"|\"\n",
+        "    else:\n",
+        "      aheads = aheads + name + \"|\"\n",
+        "    #----#\n",
+        "    sim = sorted[index].item()\n",
+        "    #----#\n",
+        "    if(is_trail[index]>0):\n",
+        "      if sim>max_sim_trail:\n",
+        "        max_sim_trail = sim\n",
+        "        max_name_trail = name\n",
+        "        max_name_trail = max_name_trail.strip()\n",
+        "\n",
+        "    else:\n",
+        "      if sim>max_sim_ahead:\n",
+        "        max_sim_ahead = sim\n",
+        "        max_name_ahead = name\n",
+        "  #------#\n",
+        "  trails = (trails + \"&&&&\").replace(\"|&&&&\", \"}\").replace(\"</w>\", \" \").replace(\"{&&&&\", \"\")\n",
+        "  aheads = (aheads + \"&&&&\").replace(\"|&&&&\", \"}\").replace(\"</w>\", \" \").replace(\"{&&&&\", \"\")\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",
+        "  print(f\"place these items ahead of prompt :  {aheads}\")\n",
+        "  print(\"\")\n",
+        "  print(f\"place these items behind the prompt : {trails}\")\n",
+        "  print(\"\")\n",
+        "\n",
+        "  tmp = must_start_with + ' ' + max_name_ahead + name_B + ' ' + must_end_with\n",
+        "  tmp = tmp.strip()\n",
+        "  print(f\"max_similarity_ahead = {round(max_sim_ahead,2)} % when using '{tmp}' \")\n",
+        "  print(\"\")\n",
+        "  tmp = must_start_with + ' ' + name_B + max_name_trail + ' ' + must_end_with\n",
+        "  tmp = tmp.strip()\n",
+        "  print(f\"max_similarity_trail = {round(max_sim_trail,2)} % when using '{tmp}' \")\n",
         "  #-----#\n",
-        "  dots[index] = sim\n",
-        "  names[index] = name\n",
-        "#------#\n",
-        "sorted, indices = torch.sort(dots,dim=0 , descending=True)\n",
-        "#------#\n",
-        "for index in range(NUM_PERMUTATIONS):\n",
-        "  print(names[indices[index].item()])\n",
+        "  #STEP 2\n",
+        "  import random\n",
+        "  names = {}\n",
+        "  NUM_PERMUTATIONS = 4\n",
+        "  #-----#\n",
+        "  dots = torch.zeros(NUM_PERMUTATIONS)\n",
+        "  for index in range(NUM_PERMUTATIONS):\n",
+        "    name_inner = ''\n",
+        "    if index == 0 : name_inner = name_B\n",
+        "    if index == 1 : name_inner = max_name_ahead\n",
+        "    if index == 2 : name_inner = name_B + max_name_trail\n",
+        "    if index == 3 : name_inner = max_name_ahead + name_B + max_name_trail\n",
+        "    name = must_start_with  + name_inner + must_end_with\n",
+        "    #----#\n",
+        "    ids = processor.tokenizer(text=name, padding=use_token_padding, return_tensors=\"pt\")\n",
+        "    #----#\n",
+        "    sim = 0\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",
+        "      logit_scale = model.logit_scale.exp()\n",
+        "      torch.matmul(text_features, image_features.t()) * logit_scale\n",
+        "      sim = torch.nn.functional.cosine_similarity(text_features, image_features) * logit_scale\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",
+        "    dots[index] = sim\n",
+        "    names[index] = name_inner\n",
+        "  #------#\n",
+        "  sorted, indices = torch.sort(dots,dim=0 , descending=True)\n",
+        "  #------#\n",
+        "  best_sim =  dots[indices[0].item()]\n",
+        "  name_B  = names[indices[0].item()].replace('</w>', ' ') #Update name_B with best value\n",
+        "#--------#\n",
+        "#store the final value\n",
+        "results_name[iter] = name_B\n",
+        "results_sim[iter] = best_sim\n",
+        "\n",
+        "sorted, indices = torch.sort(results_sim,dim=0 , descending=True)\n",
+        "\n",
+        "print('')\n",
+        "for index in range(ITERS+1):\n",
+        "  name_inner = results_name[indices[index].item()]\n",
+        "  print(must_start_with  + name_inner + must_end_with)\n",
         "  print(f'similiarity = {round(sorted[index].item(),2)} %')\n",
         "  print('------')\n",
         "#------#\n",
@@ -565,8 +617,7 @@
       ],
       "metadata": {
         "collapsed": true,
-        "id": "fi0jRruI0-tu",
-        "cellView": "form"
+        "id": "fi0jRruI0-tu"
       },
       "execution_count": null,
       "outputs": []