Upload fusion_t2i_CLIP_interrogator.ipynb

Google Colab Notebooks/fusion_t2i_CLIP_interrogator.ipynb

@@ -25,20 +25,11 @@
         "id": "cRV2YWomjMBU"
       }
     },
-    {
-      "cell_type": "markdown",
-      "source": [
-        "THIS IS AN OLD VERSION OF THE CLIP INTERROGATOR.\n",
-        "\n",
-        "YOU WILL FIND THE UP TO DATE VERSION HERE:https://huggingface.co/datasets/codeShare/fusion-t2i-generator-data/tree/main/Google%20Colab%20Jupyter%20Notebooks"
-      ],
-      "metadata": {
-        "id": "9slWHq0JIX6D"
-      }
-    },
     {
       "cell_type": "code",
       "source": [
+        "# @title ⚄ Initialize\n",
+        "\n",
         "import os\n",
         "home_directory = '/content/'\n",
         "using_Kaggle = os.environ.get('KAGGLE_URL_BASE','')\n",
@@ -69,18 +60,17 @@
         "  %cd {home_directory}\n",
         "  !git clone https://huggingface.co/datasets/codeShare/fusion-t2i-generator-data\n",
         "  loaded = True\n",
-        "  %cd {home_directory + 'fusion-t2i-generator-data/'}\n",
-        "  !unzip vocab.zip\n",
-        "  !unzip reference.zip\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",
+        "logit_scale = model.logit_scale.exp() #logit_scale = 100.00000762939453\n",
+        "\n",
+        "%cd {home_directory + 'fusion-t2i-generator-data/'}\n",
+        "!unzip reference.zip\n",
         "#------#\n",
-        "%cd {home_directory + 'fusion-t2i-generator-data/' + 'vocab'}\n",
-        "with open(f'prompts.json', 'r') as f:\n",
-        "  data = json.load(f)\n",
-        "  _df = pd.DataFrame({'count': data})['count']\n",
-        "  prompts = {\n",
-        "      key : value for key, value in _df.items()\n",
-        "  }\n",
-        "#-------#\n",
         "%cd {home_directory + 'fusion-t2i-generator-data/' + 'reference'}\n",
         "with open(f'reference_prompts.json', 'r') as f:\n",
         "  data = json.load(f)\n",
@@ -95,28 +85,11 @@
         "  target_urls = {\n",
         "      key : value for key, value in _df.items()\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",
-        "logit_scale = model.logit_scale.exp() #logit_scale = 100.00000762939453\n",
-        "\n",
-        "index = 0\n",
-        "%cd {home_directory + 'fusion-t2i-generator-data/' + 'vocab'}\n",
-        "vocab_encodings = torch.load('vocab_encodings.pt', weights_only=False)\n",
-        "for key in vocab_encodings:\n",
-        "  index = index + 1;\n",
-        "#------#\n",
-        "NUM_VOCAB_ITEMS = index\n",
         "\n",
-        "index = 0\n",
-        "%cd {home_directory + 'fusion-t2i-generator-data/' + 'reference'}\n",
-        "for key in torch.load('reference_text_and_image_encodings.pt', weights_only=False):\n",
-        "  index = index + 1;\n",
         "#------#\n",
-        "NUM_REFERENCE_ITEMS = index\n",
-        "\n"
+        "dot_dtype = torch.float32\n",
+        "dim = 768\n",
+        "reference = torch.zeros(dim).to(dtype = dot_dtype)"
       ],
       "metadata": {
         "id": "TC5lMJrS1HCC"
@@ -124,74 +97,151 @@
       "execution_count": null,
       "outputs": []
     },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Feel free to skip these cells if you do not plan on using them\n"
+      ],
+      "metadata": {
+        "id": "Xf9zoq-Za3wi"
+      }
+    },
     {
       "cell_type": "code",
       "source": [
-        "# @title \t⚄ Use a pre-encoded prompt + image pair from the fusion gen (note: NSFW!)\n",
-        "# @markdown Choose a pre-encoded reference\n",
-        "index = 213 # @param {type:\"slider\", min:0, max:1666, step:1}\n",
+        "# @markdown 🖼️+📝 Choose a pre-encoded reference (optional)\n",
+        "index = 657 # @param {type:\"slider\", min:0, max:1666, step:1}\n",
         "PROMPT_INDEX = index\n",
         "prompt = target_prompts[f'{PROMPT_INDEX}']\n",
         "url = target_urls[f'{PROMPT_INDEX}']\n",
         "if url.find('perchance')>-1:\n",
         "  image = Image.open(requests.get(url, stream=True).raw)\n",
         "#------#\n",
+        "try: reference\n",
+        "except: reference = torch.zeros(dim).to(dtype = dot_dtype)\n",
+        "if reference == '': reference = torch.zeros(dim).to(dtype = dot_dtype)\n",
         "# @markdown ⚖️ 🖼️ encoding <-----?-----> 📝 encoding </div> <br>\n",
         "C = 0.3 # @param {type:\"slider\", min:0, max:1, step:0.01}\n",
-        "log_strength_1 = 2.17 # @param {type:\"slider\", min:-5, max:5, step:0.01}\n",
-        "prompt_strength = torch.tensor(math.pow(10 ,log_strength_1-1)).to(dtype = torch.float32)\n",
-        "reference = torch.zeros(768).to(dtype = torch.float32)\n",
-        "\n",
+        "log_strength = 1 # @param {type:\"slider\", min:-5, max:5, step:0.01}\n",
         "%cd {home_directory + 'fusion-t2i-generator-data/' + 'reference'}\n",
         "references = torch.load('reference_text_and_image_encodings.pt'  , weights_only=False)\n",
-        "reference = torch.add(reference, prompt_strength * C * references[index][0].dequantize().to(dtype = torch.float32))\n",
-        "reference = torch.add(reference, prompt_strength * (1-C) * references[index][1].dequantize().to(dtype = torch.float32))\n",
+        "reference = torch.add(reference, math.pow(10 ,log_strength-1) * C * references[index][0].dequantize().to(dtype = torch.float32))\n",
+        "reference = torch.add(reference, math.pow(10 ,log_strength-1) * (1-C) * references[index][1].dequantize().to(dtype = torch.float32))\n",
         "references = '' # Clear up memory\n",
-        "# @markdown -----------\n",
-        "# @markdown 📝➕ 1st Enhance similarity to prompt(s)\n",
-        "POS_2 = '' # @param {type:'string' ,placeholder:'item1 , item2 , ...'}\n",
-        "log_strength_2 = 1.03 # @param {type:\"slider\", min:-5, max:5, step:0.01}\n",
-        "pos_strength = torch.tensor(math.pow(10 ,log_strength_2-1)).to(dtype = torch.float32)\n",
-        "for _POS in POS_2.replace('</w>' , ' ').replace('{' , '').replace('}' , '').replace('|' , ',').split(','):\n",
-        "  inputs = tokenizer(text = _POS.strip(), truncation = True  , padding=True, return_tensors=\"pt\")\n",
-        "  text_features_POS = model.get_text_features(**inputs).to(dtype = torch.float32)\n",
-        "  text_features_POS = text_features_POS/text_features_POS.norm(p=2, dim=-1, keepdim=True)\n",
-        "  reference = torch.add(reference, pos_strength * text_features_POS)\n",
-        "# @markdown -----------\n",
-        "\n",
-        "# @markdown -----------\n",
-        "# @markdown 📝➕ 2nd Enhance similarity to prompt(s)\n",
-        "POS = '' # @param {type:'string' ,placeholder:'item1 , item2 , ...'}\n",
-        "log_strength_3 = 1.06 # @param {type:\"slider\", min:-5, max:5, step:0.01}\n",
-        "pos_strength = torch.tensor(math.pow(10 ,log_strength_3-1)).to(dtype = torch.float32)\n",
-        "for _POS in POS.replace('</w>' , ' ').replace('{' , '').replace('}' , '').replace('|' , ',').split(','):\n",
-        "  inputs = tokenizer(text = _POS.strip(), truncation = True  , padding=True, return_tensors=\"pt\")\n",
-        "  text_features_POS = model.get_text_features(**inputs).to(dtype = torch.float32)\n",
-        "  text_features_POS = text_features_POS/text_features_POS.norm(p=2, dim=-1, keepdim=True)\n",
-        "  reference = torch.add(reference, pos_strength * text_features_POS)\n",
-        "# @markdown -----------\n",
-        "\n",
-        "# @markdown 🚫 Penalize similarity to prompt(s)\n",
-        "NEG = '' # @param {type:'string' , placeholder:'item1 , item2 , ...'}\n",
-        "log_strength_4 = 1 # @param {type:\"slider\", min:-5, max:5, step:0.01}\n",
-        "neg_strength = torch.tensor(math.pow(10 ,log_strength_4-1)).to(dtype = torch.float32)\n",
-        "for _NEG in NEG.replace('</w>' , ' ').replace('{' , '').replace('}' , '').replace('|' , ',').split(','):\n",
-        "  inputs = tokenizer(text = _NEG.strip(), truncation = True  , padding=True, return_tensors=\"pt\")\n",
-        "  text_features_NEG = model.get_text_features(**inputs).to(dtype = torch.float32)\n",
-        "  text_features_NEG = text_features_NEG/text_features_NEG.norm(p=2, dim=-1, keepdim=True)\n",
-        "  reference = torch.sub(reference, neg_strength * text_features_NEG)\n",
-        "# @markdown -----------\n",
-        "# @markdown ⏩ Skip item(s) containing the word(s)\n",
-        "SKIP = '' # @param {type:'string' , placeholder:'item1 , item2 , ...'}\n",
+        "ref = reference.clone().detach()\n",
+        "#------#\n",
+        "print(f'Prompt for this image : \\n\\n \"{prompt} \" \\n\\n')\n",
+        "image"
+      ],
+      "metadata": {
+        "id": "BwrEs5zVB0Sb"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @markdown 🖼️ Upload your own image for use as reference via URL (optional)\n",
+        "URL = '' # @param {type:'string' ,placeholder:'paste an url here'}\n",
+        "image = Image.open(requests.get(URL, stream=True).raw)\n",
+        "#---------#\n",
+        "# Get image features\n",
+        "inputs = processor(images=image, return_tensors=\"pt\")\n",
+        "image_features = model.get_image_features(**inputs)\n",
+        "image_features = image_features / image_features.norm(p=2, dim=-1, keepdim=True)\n",
+        "#-----#\n",
+        "log_strength = 1 # @param {type:\"slider\", min:-5, max:5, step:0.01}\n",
+        "ref = ref + math.pow(10,log_strength-1)*image_features\n",
+        "image"
+      ],
+      "metadata": {
+        "id": "IqUsiQw2HU2C"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @markdown 🖼️ Upload your own image in the /content/ folder for use as reference (optional)\n",
+        "FILENAME = '' # @param {type:'string' ,placeholder:'IMG_123.png'}\n",
+        "import cv2\n",
+        "image = cv2.imread(FILENAME)\n",
+        "image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
         "\n",
+        "#---------#\n",
+        "# Get image features\n",
+        "inputs = processor(images=image, return_tensors=\"pt\")\n",
+        "image_features = model.get_image_features(**inputs)\n",
+        "image_features = image_features / image_features.norm(p=2, dim=-1, keepdim=True)\n",
+        "#-----#\n",
+        "log_strength = 1 # @param {type:\"slider\", min:-5, max:5, step:0.01}\n",
+        "ref = ref + math.pow(10,log_strength-1)*image_features\n",
+        "image"
+      ],
+      "metadata": {
+        "id": "I_-GOwFPKkha"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Save the reference prior to running the Interrogator"
+      ],
+      "metadata": {
+        "id": "zeu6JcM-mk9z"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title ⚄ Save the reference\n",
+        "try: ref\n",
+        "except: ref = torch.zeros(dim)\n",
+        "_ref = {}\n",
+        "_ref['weights'] = ref.to(dot_dtype)\n",
+        "%cd /content/\n",
+        "save_file(_ref , 'reference.safetensors' )"
+      ],
+      "metadata": {
+        "id": "lOQuTPfBMK82"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title ⚄ Run the CLIP interrogator on the saved reference\n",
+        "LIST_SIZE = 1000  # @param {type:'number' , placeholder:'set how large the list should be'}\n",
+        "START_AT = 0  # @param {type:'number' , placeholder:'set how large the list should be'}\n",
+        "# @markdown -----\n",
+        "# @markdown Select vocab\n",
+        "general = False # @param {type:\"boolean\"}\n",
+        "civit9 = True # @param {type:\"boolean\"}\n",
+        "fanfic1 = False # @param {type:\"boolean\"}\n",
+        "fanfic2 = False # @param {type:\"boolean\"}\n",
+        "# @markdown -----\n",
+        "# @title ⚄ New interrogator code using quantized text corpus\n",
+        "%cd /content/\n",
+        "_ref = load_file('reference.safetensors' )\n",
+        "ref = _ref['weights'].to(dot_dtype)\n",
+        "# @markdown 📝 Enhance/Penalize Similarity and skip items containing word(s)\n",
+        "POS1 = '' # @param {type:'string' ,placeholder:'item1 , item2 , ...'}\n",
+        "POS2 = '' # @param {type:'string' ,placeholder:'item1 , item2 , ...'}\n",
+        "NEG = ''# @param {type:'string' ,placeholder:'item1 , item2 , ...'}\n",
+        "SKIP = '' # @param {type:'string' ,placeholder:'item1 , item2 , ...'}\n",
         "min_wordcount = 0 # @param {type:\"slider\", min:0, max:20, step:1}\n",
-        "\n",
-        "def isBlacklisted(_txt, _blacklist):\n",
-        "  blacklist =  _blacklist.lower().replace('</w>' , ' ').replace('{' , '').replace('}' , '').replace('|' , ',').strip()\n",
+        "def isBlacklisted(_txt):\n",
+        "  blacklist =  SKIP.lower().replace('</w>' , ' ').replace('{' , '').replace('}' , '').replace('|' , ',').strip()\n",
+        "  if blacklist == '': return False\n",
         "  txt = _txt.lower().strip()\n",
         "  if len(txt)<min_wordcount: return True\n",
         "  if txt.isnumeric(): return True\n",
-        "  if blacklist == '': return False\n",
+        "  #-----#\n",
         "  for item in list(blacklist.split(',')):\n",
         "    if item.strip() == '' : continue\n",
         "    if txt.find(item.strip())> -1 : return True\n",
@@ -203,76 +253,112 @@
         "    if found:break\n",
         "  #------#\n",
         "  return not found\n",
+        "# @markdown -----\n",
+        "# @markdown logarithmic prompt strength x for value 10^(x-1)\n",
+        "_POS1 = 1 # @param {type:\"slider\", min:-5, max:5, step:0.01}\n",
+        "_POS2 = 1 # @param {type:\"slider\", min:-5, max:5, step:0.01}\n",
+        "_NEG = 1 # @param {type:\"slider\", min:-5, max:5, step:0.01}\n",
+        "# @markdown -----\n",
+        "for _item in POS1.split(','):\n",
+        "  item = _item.strip()\n",
+        "  if item == '':continue\n",
+        "  inputs = tokenizer(text = item.strip(), truncation = True  , padding=True, return_tensors=\"pt\")\n",
+        "  ref = ref + math.pow(10,_POS1-1) * model.get_text_features(**inputs)[0]\n",
+        "#-------#\n",
+        "for _item in POS2.split(','):\n",
+        "  item = _item.strip()\n",
+        "  if item == '':continue\n",
+        "  inputs = tokenizer(text = item.strip(), truncation = True  , padding=True, return_tensors=\"pt\")\n",
+        "  ref = ref + math.pow(10,_POS2-1) * model.get_text_features(**inputs)[0]\n",
+        "#-------#\n",
+        "for _item in NEG.split(','):\n",
+        "  item = _item.strip()\n",
+        "  if item == '':continue\n",
+        "  inputs = tokenizer(text = item.strip(), truncation = True  , padding=True, return_tensors=\"pt\")\n",
+        "  ref = ref + math.pow(10,_NEG-1) * model.get_text_features(**inputs)[0]\n",
+        "#------#\n",
+        "ref = (ref/ref.norm(p=2, dim=-1, keepdim=True)).to(dtype = dot_dtype)\n",
+        "vocab_to_load = ''\n",
+        "if (general): vocab_to_load = vocab_to_load + 'general , '\n",
+        "if (civit9): vocab_to_load = vocab_to_load + 'civit9 , '\n",
+        "if (fanfic1): vocab_to_load = vocab_to_load + 'fanfic1 , '\n",
+        "if (fanfic2): vocab_to_load = vocab_to_load + 'fanfic2 , '\n",
+        "vocab_to_load = (vocab_to_load +'}').replace(' , }' , '')\n",
+        "multi = vocab_to_load.find(',')>-1\n",
         "\n",
-        "# @markdown -----------\n",
-        "# @markdown 🔍 How similar should the results be?\n",
-        "list_size = 1000 # @param {type:'number'}\n",
-        "start_at_index = 1 # @param {type:'number'}\n",
-        "# @markdown -----------\n",
-        "# @markdown Repeat output N times\n",
-        "N = 7 # @param {type:\"slider\", min:0, max:20, step:1}\n",
-        "# @markdown -----------\n",
-        "# @markdown ⚙️ Run the script?\n",
-        "update_list = True # @param {type:\"boolean\"}\n",
-        "\n",
-        "calculate_variance  = False # @param {type:\"boolean\"}\n",
+        "#-----#\n",
+        "prompts_folder = f'{home_directory}fusion-t2i-generator-data/vocab-v2/text'\n",
+        "encodings_folder = f'{home_directory}fusion-t2i-generator-data/vocab-v2/text_encodings'\n",
+        "#----#\n",
+        "scale = 0.0043\n",
+        "size = 0\n",
+        "#------#\n",
+        "total_items = 0\n",
+        "for filename in os.listdir(prompts_folder):\n",
+        "  if (not general and filename.find('general')>-1):continue\n",
+        "  if (not civit9 and filename.find('civit9')>-1):continue\n",
+        "  if (not fanfic1 and filename.find('fanfic1')>-1):continue\n",
+        "  if (not fanfic2 and filename.find('fanfic2')>-1):continue\n",
+        "  size = size + LIST_SIZE\n",
+        "#-------#\n",
+        "similiar_sims = torch.zeros(size)\n",
+        "similiar_prompts = {}\n",
+        "_index = 0\n",
+        "#-------#\n",
+        "similiar_encodings = {}\n",
+        "for filename in os.listdir(prompts_folder):\n",
+        "  if (not general and filename.find('general')>-1):continue\n",
+        "  if (not civit9 and filename.find('civit9')>-1):continue\n",
+        "  if (not fanfic1 and filename.find('fanfic1')>-1):continue\n",
+        "  if (not fanfic2 and filename.find('fanfic2')>-1):continue\n",
+        "  #------#\n",
+        "  root_filename = filename.replace('.json', '')\n",
+        "  %cd {prompts_folder}\n",
+        "  prompts = {}\n",
+        "  with open(f'{root_filename}.json', 'r') as f:\n",
+        "    data = json.load(f).items()\n",
+        "    for key,value in data:\n",
+        "      prompts[key] = value\n",
+        "  num_items = int(prompts['num_items'])\n",
+        "  total_items = total_items + num_items\n",
         "\n",
-        "ne = update_list\n",
+        "  #------#\n",
+        "  try:vocab_loaded\n",
+        "  except:\n",
+        "    vocab_loaded = 'first'\n",
+        "  #-----#\n",
         "\n",
-        "try: first\n",
-        "except:\n",
-        "  enable = True\n",
-        "  first = True\n",
+        "  if  vocab_loaded == 'first' or (vocab_loaded != vocab_to_load and not multi):\n",
+        "    %cd {encodings_folder}\n",
+        "    _text_encodings = load_file(f'{root_filename}.safetensors')['weights'].to(torch.uint8)\n",
+        "    text_encodings = torch.zeros(num_items , dim)\n",
+        "    tmp = torch.ones(dim).to(dot_dtype)\n",
+        "    for index in range(num_items):\n",
+        "      text_encodings[index] = torch.sub(_text_encodings[index][1:dim+1].to(dot_dtype) , tmp , alpha= _text_encodings[index][0].to(dot_dtype))\n",
+        "    vocab_loaded = vocab_to_load\n",
+        "  #------#\n",
         "\n",
-        "if (enable):\n",
-        "  reference = reference/reference.norm(p=2, dim=-1, keepdim=True)\n",
-        "  %cd {home_directory + 'fusion-t2i-generator-data/' + 'vocab'}\n",
-        "  sims = torch.matmul(vocab_encodings.dequantize(),reference.t())\n",
-        "  sorted , indices = torch.sort(sims,dim=0 , descending=True)\n",
         "\n",
-        "  if calculate_variance:\n",
-        "    average = torch.zeros(768)\n",
-        "    for key in range(NUM_VOCAB_ITEMS):\n",
-        "      if (key>=start_at_index and key < start_at_index + list_size):\n",
-        "        average = torch.add(average, vocab_encodings[key].dequantize())\n",
-        "      if (key>=start_at_index + list_size) : break\n",
-        "    average = average * (1/max(1, list_size))\n",
-        "    average = average/average.norm(p=2, dim=-1, keepdim=True)\n",
-        "    average = average.clone().detach();\n",
-        "    variance = torch.zeros(1)\n",
-        "    for key in range(NUM_VOCAB_ITEMS):\n",
-        "      if (key>=start_at_index and key < start_at_index + list_size):\n",
-        "        #dot product\n",
-        "        difference_to_average = 100 * (torch.ones(1) - torch.dot(average[0]\n",
-        "        , vocab_encodings[key].dequantize()[0])/average.norm(p=2, dim=-1, keepdim=True))\n",
-        "        variance =  torch.add(variance, difference_to_average * difference_to_average)\n",
-        "      if (key>=start_at_index + list_size) : break\n",
-        "    #--------#\n",
-        "    variance =  variance * (1/max(1, list_size))\n",
-        "    variance= variance.clone().detach();\n",
-        "    print(f'The variance for the selected range is {math.sqrt(variance.item())} units from average')\n",
-        "  #--------#\n",
-        "#---#\n",
-        "output = '{'\n",
-        "for _index in range(list_size):\n",
-        "  tmp = prompts[f'{indices[min(_index+start_at_index,NUM_VOCAB_ITEMS-1)].item()}']\n",
-        "  if isBlacklisted(tmp , SKIP): continue\n",
-        "  tmp = fix_bad_symbols(tmp)\n",
-        "  if output.find(tmp)>-1:continue\n",
-        "  output = output + tmp + '|'\n",
+        "  sims = torch.matmul(text_encodings*scale, ref.t())\n",
+        "  sorted , indices = torch.sort(sims , dim=0 , descending = True)\n",
+        "  #-----#\n",
+        "  for index in range(LIST_SIZE + START_AT):\n",
+        "    if index<START_AT: continue\n",
+        "    key = indices[index].item()\n",
+        "    try:prompt = prompts[f'{key}']\n",
+        "    except:continue\n",
+        "    if(isBlacklisted(prompt)):continue\n",
+        "    #-------#\n",
+        "    similiar_sims[_index] = torch.tensor(round(sims[key].item(), 5))\n",
+        "    similiar_prompts[f'{_index}'] = prompt\n",
+        "    _index = _index + 1\n",
+        "  #-------#\n",
+        "  continue\n",
         "#---------#\n",
-        "output = (output + '}').replace('|}' , '} ')\n",
-        "print('')\n",
-        "print('')\n",
-        "for iter in range(N):\n",
-        "  print(output)\n",
-        "#-------#\n",
-        "print('')\n",
-        "print('')\n",
-        "image or print('No image found')"
+        "print(f'\\n\\nProcessed entire list of {total_items} items to find closest match. Saved closest matching indices {START_AT} to {START_AT + LIST_SIZE} as the dict \"similiar_prompts\" with {LIST SIZE} items. \\n\\n')\n"
       ],
       "metadata": {
-        "id": "NqL_I3ZSrISq"
+        "id": "kOYZ8Ajn-DD8"
       },
       "execution_count": null,
       "outputs": []
@@ -280,89 +366,50 @@
     {
       "cell_type": "code",
       "source": [
-        "# Check the average value for this set\n",
-        "sims = torch.matmul(vocab_encodings.dequantize(),average.t())\n",
-        "sorted , indices = torch.sort(sims,dim=0 , descending=True)\n",
-        "for index in range(10):\n",
-        "  print(prompts[f'{indices[index].item()}'])"
+        "\n",
+        "# @title ⚄ Printing results from text corpus\n",
+        "sorted , indices = torch.sort(similiar_sims , dim=0 , descending = True)\n",
+        "include_similiarity = False # @param {type:\"boolean\"}\n",
+        "print_as_list = False # @param {type:\"boolean\"}\n",
+        "N = 7 # @param {type:\"slider\", min:0, max:10, step:1}\n",
+        "\n",
+        "if(print_as_list):\n",
+        "  for index in range(LIST_SIZE):\n",
+        "    key = indices[index].item()\n",
+        "    sim = similiar_sims[key].item()\n",
+        "    prompt = similiar_prompts[f'{key}']\n",
+        "    if include_similiarity :print(f'{prompt}  - {round(sim*100,1)} %')\n",
+        "    else: print(f'{prompt}')\n",
+        "#-------#\n",
+        "else:\n",
+        "  prompt = ''\n",
+        "  for iter in range(N):\n",
+        "    prompt = prompt + '{'\n",
+        "    for index in range(LIST_SIZE):\n",
+        "      key = indices[index].item()\n",
+        "      sim = similiar_sims[key].item()\n",
+        "      prompt = prompt + fix_bad_symbols(similiar_prompts[f'{key}']) + '|'\n",
+        "    #-----#\n",
+        "    prompt = (prompt + '}').replace('|}',  '} ')\n",
+        "  #------#\n",
+        "  print(f'\\ Similiar prompts: \\n\\n {prompt} \\n\\n')\n",
+        "  image\n",
+        "#-----#\n"
       ],
       "metadata": {
-        "id": "XNHz0hfhHRUu"
+        "id": "XOMkIKc9-wZz"
       },
       "execution_count": null,
       "outputs": []
     },
     {
-      "cell_type": "code",
+      "cell_type": "markdown",
       "source": [
-        "# @title ⚙️📝 Print the results (Advanced)\n",
-        "list_size = 1000 # @param {type:'number'}\n",
-        "start_at_index = 0 # @param {type:'number'}\n",
-        "print_Similarity = True # @param {type:\"boolean\"}\n",
-        "print_Prompts = True # @param {type:\"boolean\"}\n",
-        "print_Descriptions = True # @param {type:\"boolean\"}\n",
-        "compact_Output = True # @param {type:\"boolean\"}\n",
-        "newline_Separator = False # @param {type:\"boolean\"}\n",
-        "\n",
-        "import random\n",
-        "# @markdown -----------\n",
-        "# @markdown Mix with...\n",
-        "list_size2 = 1000 # @param {type:'number'}\n",
-        "start_at_index2 = 10000 # @param {type:'number'}\n",
-        "rate_percent  = 0 # @param {type:\"slider\", min:0, max:100, step:1}\n",
-        "\n",
-        "# @markdown -----------\n",
-        "# @markdown Repeat output N times\n",
-        "N = 6 # @param {type:\"slider\", min:0, max:10, step:1}\n",
-        "\n",
-        "# title Show the 100 most similiar suffix and prefix text-encodings to the text encoding\n",
-        "RANGE = list_size\n",
-        "separator = '|'\n",
-        "if newline_Separator : separator = separator + '\\n'\n",
-        "\n",
-        "_prompts = ''\n",
-        "_sims =  ''\n",
-        "for _index in range(start_at_index + RANGE):\n",
-        "  if _index < start_at_index : continue\n",
-        "  index = indices[_index].item()\n",
-        "\n",
-        "  prompt = prompts[f'{index}']\n",
-        "  if rate_percent >= random.randint(0,100) : prompt = prompts[f'{random.randint(start_at_index2 , start_at_index2 + list_size2)}']\n",
-        "\n",
-        "  #Remove duplicates\n",
-        "  if _prompts.find(prompt + separator)<=-1:\n",
-        "    _sims = _sims + f'{round(100*sims[index].item(), 2)} %' + separator\n",
-        "  #-------#\n",
-        "  _prompts = _prompts.replace(prompt + separator,'')\n",
-        "  _prompts = _prompts  + prompt + separator\n",
-        "  #------#\n",
-        "#------#\n",
-        "__prompts = fix_bad_symbols(__prompts)\n",
-        "__prompts = ('{' + _prompts + '}').replace(separator + '}', '}')\n",
-        "__sims = ('{' + _sims + '}').replace(separator + '}', '}')\n",
-        "#------#\n",
-        "\n",
-        "if(not print_Prompts): __prompts = ''\n",
-        "if(not print_Similarity): __sims = ''\n",
-        "\n",
-        "if(not compact_Output):\n",
-        "  if(print_Descriptions):\n",
-        "    print(f'The {start_at_index}-{start_at_index + RANGE} most similiar items to prompt : \\n\\n ')\n",
-        "    for i in range(N) : print(__prompts)\n",
-        "    print(f'The {start_at_index}-{start_at_index + RANGE} similarity % for items : \\n\\n' + __sims)\n",
-        "    print('')\n",
-        "  else:\n",
-        "    for i in range(N) : print(__prompts)\n",
-        "else:\n",
-        "  for i in range(N) : print(__prompts)\n",
-        "#-------#"
+        "OTHER STUFF BELOW - Code for the modules below are work-in-progress."
       ],
       "metadata": {
-        "id": "EdBiAguJO9aX",
-        "cellView": "form"
-      },
-      "execution_count": null,
-      "outputs": []
+        "id": "FRIqYJDEebpf"
+      }
     },
     {
       "cell_type": "markdown",
@@ -605,59 +652,54 @@
     {
       "cell_type": "code",
       "source": [
-        "# @title \t⚄ New code (work in progress)\n",
-        "\n",
-        "def get_num_vocab_items(_url):\n",
-        "  num_vocab_items = 0\n",
-        "  for item in _url.split('_'):\n",
-        "    if item.find('safetensors')>-1: num_vocab_items = int(item.replace('.safetensors', ''))\n",
-        "  #------#\n",
-        "  return num_vocab_items-1\n",
+        "# @title \t⚄ Quick fix for normalizing encoded text corpus tensors\n",
         "\n",
+        "import os\n",
+        "my_mkdirs('/content/output')\n",
+        "my_mkdirs('/content/output/text_encodings')\n",
         "\n",
-        "def get_similiar(_ref , urls, _LIST_SIZE):\n",
-        "  dot_dtype = torch.float16\n",
-        "  _SCALE = torch.tensor(0.0043).to(dot_dtype)\n",
-        "  _DIM = 768\n",
-        "  _vocab = {}\n",
-        "  #----#\n",
-        "  inputs = tokenizer(text = _ref.strip(), truncation = True  , padding=True, return_tensors=\"pt\")\n",
-        "  ref = model.get_text_features(**inputs)[0]\n",
-        "  ref = (ref/ref.norm(p=2, dim=-1, keepdim=True)).to(dtype = dot_dtype)\n",
-        "  #-----#\n",
-        "  num_vocab_items = 0\n",
-        "  for url in urls:\n",
-        "    num_vocab_items = num_vocab_items + get_num_vocab_items(url)\n",
-        "  #------#\n",
-        "  vocab = torch.zeros(num_vocab_items , _DIM).to(torch.uint8)\n",
+        "for filename in os.listdir(f'{prompts_folder}'):\n",
+        "  %cd {prompts_folder}\n",
         "  prompts = {}\n",
-        "  index = 0\n",
-        "  for url in urls:\n",
-        "    __vocab = load_file(url)\n",
-        "    for key in load_file(url):\n",
-        "      vocab[index] = __vocab[key][1:_DIM+1] - __vocab[key][0]*torch.ones(_DIM).t()\n",
-        "      prompts[f'{index}'] = key\n",
-        "      index = index + 1\n",
-        "    #-------#\n",
-        "    __vocab = {}\n",
-        "  #-------#\n",
-        "  sims = torch.matmul((vocab*_SCALE).to(dot_dtype) , ref.t())\n",
-        "  sorted , indices = torch.sort(sims, dim = 0 , descending = True)\n",
-        "  return indices , prompts , sims\n",
-        "  _prompts = {}\n",
-        "  for index in range(num_vocab_items):\n",
-        "    key = prompts[f'{indices[index]}']\n",
-        "    _prompts[f'{key}'] = sims[key].item()\n",
-        "    index = index + 1\n",
-        "    if index>_LIST_SIZE:break\n",
+        "  with open(f'{filename}', 'r') as f:\n",
+        "    data = json.load(f).items()\n",
+        "    for key,value in data:\n",
+        "      prompts[key] = value\n",
+        "    #------#\n",
+        "  num_items = int(prompts['num_items'])\n",
+        "\n",
+        "  %cd {encodings_folder}\n",
+        "  enc_filename = filename.replace('json', 'safetensors')\n",
+        "  _text_encodings = load_file(f'{enc_filename}')['weights'].to(torch.uint8)\n",
+        "  text_encodings = torch.zeros(num_items , dim)\n",
+        "  tmp = torch.ones(dim)\n",
+        "  tmp2 = torch.tensor(1/0.0043)\n",
+        "  zero_point = 0\n",
+        "  for index in range(num_items):\n",
+        "    text_encodings[index] = torch.tensor(0.0043) * torch.sub(_text_encodings[index][1:dim+1] , tmp , alpha= _text_encodings[index][0]).to(torch.float32)\n",
+        "    text_encodings[index] = tmp2*text_encodings[index]/text_encodings[index].norm(p=2, dim=-1, keepdim = True)\n",
+        "    test = torch.round( torch.add(text_encodings[index],tmp*zero_point))\n",
+        "    less_than_zero = test<0\n",
+        "    while(torch.any(less_than_zero).item()):\n",
+        "      zero_point = zero_point + 1\n",
+        "      test = torch.round( torch.add(text_encodings[index],tmp*zero_point))\n",
+        "      less_than_zero = test<0\n",
+        "    #------#\n",
+        "    _text_encodings[index][0]  = zero_point\n",
+        "    _text_encodings[index][1:dim+1] = test\n",
         "  #-------#\n",
-        "  return _prompts\n",
-        "#-------#\n",
-        "\n"
+        "  %cd /content/output/text_encodings\n",
+        "\n",
+        "  tmp = {}\n",
+        "  tmp['weights'] =  _text_encodings.to(torch.uint8)\n",
+        "  tmp['num_items'] = torch.tensor(num_items).to(torch.uint8)\n",
+        "  tmp['scale'] = torch.tensor(0.0043)\n",
+        "  save_file(tmp , f'{enc_filename}')\n",
+        "#------#"
       ],
       "metadata": {
         "cellView": "form",
-        "id": "uDzsk02CbMFc"
+        "id": "9qgHW1Wr7kZn"
       },
       "execution_count": null,
       "outputs": []
@@ -665,31 +707,14 @@
     {
       "cell_type": "code",
       "source": [
-        "vocab = {}\n",
-        "# @title \t⚄ New code (work in progress)\n",
-        "ref = 'impressionist painting by luis royo' # @param {type:'string' , placeholder:'type a single prompt to match'}\n",
-        "LIST_SIZE = 1000  # @param {type:'number' , placeholder:'set how large the list should be'}\n",
-        "urls = [ '/content/fusion-t2i-generator-data/civitai_vocab_q0043_203663.safetensors' ,]\n",
-        "\n",
-        "         #'/content/fusion-t2i-generator-data/clip_vocab_q0043_541291.safetensors' , '/content/fusion-t2i-generator-data/lyrics_vocab_q0043_41905.safetensors' , '/content/fusion-t2i-generator-data/names_vocab_q0043_162977.safetensors' , '/content/fusion-t2i-generator-data/r34_vocab_q0043_96166.safetensors' ]\n",
-        "\n",
-        "indices , prompts , sims = get_similiar(ref , urls , LIST_SIZE)\n",
-        "\n",
-        "index = 0\n",
-        "_prompts = {}\n",
-        "for index in range(203662):\n",
-        "  try:\n",
-        "    key = prompts[f'{indices[index].item()}']\n",
-        "    print(key)\n",
-        "  except: print('Not found!')\n",
-        "  #_prompts[f'{key}'] = sims[key].item()\n",
-        "  index = index + 1\n",
-        "  if index>LIST_SIZE:break\n",
-        "\n"
+        "# Check the average value for this set\n",
+        "sims = torch.matmul(vocab_encodings.dequantize(),average.t())\n",
+        "sorted , indices = torch.sort(sims,dim=0 , descending=True)\n",
+        "for index in range(10):\n",
+        "  print(prompts[f'{indices[index].item()}'])"
       ],
       "metadata": {
-        "cellView": "form",
-        "id": "Azz1kCza6LB3"
+        "id": "XNHz0hfhHRUu"
       },
       "execution_count": null,
       "outputs": []