Upload 7 files

openclip/calculate-vitb.py

@@ -0,0 +1,94 @@
+#!/bin/env python
+
+""" 
+Plan:
+   Read in "dictionary" for list of words
+   Read in pre-calculated "proper" embedding for each word from safetensor file
+   Prompt user for a word from the list
+   Generate a tensor array of distance to all the other known words
+   Print out the 20 closest ones
+"""
+
+
+import sys
+import torch
+import open_clip
+
+from safetensors import safe_open
+
+#from transformers import CLIPProcessor,CLIPModel
+
+device=torch.device("cuda")
+
+mtype='ViT-B-32'
+mname='laion2b_s34b_b79k'
+
+print("Loading",mtype,mname)
+
+cmodel, _, preprocess = open_clip.create_model_and_transforms(mtype,
+        pretrained=mname)
+tokenizer = open_clip.get_tokenizer(mtype)
+
+## model = model.to(device)
+
+
+#embed_file="embeddings.safetensors"
+embed_file=sys.argv[1]
+dictionary=sys.argv[2]
+
+
+print(f"read in words from {dictionary} now",file=sys.stderr)
+with open(dictionary,"r") as f:
+    tokendict = f.readlines()
+    wordlist = [token.strip() for token in tokendict]  # Remove trailing newlines
+print(len(wordlist),"lines read")
+
+print(f"read in {embed_file} now",file=sys.stderr)
+emodel = safe_open(embed_file,framework="pt",device="cuda")
+embs=emodel.get_tensor("embeddings")
+embs.to(device)
+print("Shape of loaded embeds =",embs.shape)
+
+def standard_embed_calc(text):
+    with torch.no_grad():
+        ttext = tokenizer(text)
+        text_features = cmodel.encode_text(ttext)
+    embedding = text_features[0]
+    #print("shape of text is",ttext.shape)
+    return embedding
+
+
+def print_distances(targetemb):
+    targetdistances = torch.cdist( targetemb.unsqueeze(0), embs, p=2)
+
+    print("shape of distances...",targetdistances.shape)
+
+    smallest_distances, smallest_indices = torch.topk(targetdistances[0], 20, largest=False)
+
+    smallest_distances=smallest_distances.tolist()
+    smallest_indices=smallest_indices.tolist()
+    for d,i in zip(smallest_distances,smallest_indices):
+        print(wordlist[i],"(",d,")")
+
+
+
+# Find 10 closest tokens to targetword.
+# Will include the word itself
+def find_closest(targetword):
+    try:
+        targetindex=wordlist.index(targetword)
+        targetemb=embs[targetindex]
+        print_distances(targetemb)
+        return
+    except ValueError:
+        print(targetword,"not found in cache")
+
+
+    print("Now doing with full calc embed")
+    targetemb=standard_embed_calc(targetword)
+    print_distances(targetemb)
+
+
+while True:
+    input_text=input("Input a word now:")
+    find_closest(input_text)

openclip/calculate-vitg.py

@@ -0,0 +1,94 @@
+#!/bin/env python
+
+""" 
+Plan:
+   Read in "dictionary" for list of words
+   Read in pre-calculated "proper" embedding for each word from safetensor file
+   Prompt user for a word from the list
+   Generate a tensor array of distance to all the other known words
+   Print out the 20 closest ones
+"""
+
+
+import sys
+import torch
+import open_clip
+
+from safetensors import safe_open
+
+#from transformers import CLIPProcessor,CLIPModel
+
+device=torch.device("cuda")
+
+mtype='ViT-g-14'
+mname='laion2b_s12b_b42k'
+
+print("Loading",mtype,mname)
+
+cmodel, _, preprocess = open_clip.create_model_and_transforms(mtype,
+        pretrained=mname)
+tokenizer = open_clip.get_tokenizer(mtype)
+
+## model = model.to(device)
+
+
+#embed_file="embeddings.safetensors"
+embed_file=sys.argv[1]
+dictionary=sys.argv[2]
+
+
+print(f"read in words from {dictionary} now",file=sys.stderr)
+with open(dictionary,"r") as f:
+    tokendict = f.readlines()
+    wordlist = [token.strip() for token in tokendict]  # Remove trailing newlines
+print(len(wordlist),"lines read")
+
+print(f"read in {embed_file} now",file=sys.stderr)
+emodel = safe_open(embed_file,framework="pt",device="cuda")
+embs=emodel.get_tensor("embeddings")
+embs.to(device)
+print("Shape of loaded embeds =",embs.shape)
+
+def standard_embed_calc(text):
+    with torch.no_grad():
+        ttext = tokenizer(text)
+        text_features = cmodel.encode_text(ttext)
+    embedding = text_features[0]
+    #print("shape of text is",ttext.shape)
+    return embedding
+
+
+def print_distances(targetemb):
+    targetdistances = torch.cdist( targetemb.unsqueeze(0), embs, p=2)
+
+    print("shape of distances...",targetdistances.shape)
+
+    smallest_distances, smallest_indices = torch.topk(targetdistances[0], 20, largest=False)
+
+    smallest_distances=smallest_distances.tolist()
+    smallest_indices=smallest_indices.tolist()
+    for d,i in zip(smallest_distances,smallest_indices):
+        print(wordlist[i],"(",d,")")
+
+
+
+# Find 10 closest tokens to targetword.
+# Will include the word itself
+def find_closest(targetword):
+    try:
+        targetindex=wordlist.index(targetword)
+        targetemb=embs[targetindex]
+        print_distances(targetemb)
+        return
+    except ValueError:
+        print(targetword,"not found in cache")
+
+
+    print("Now doing with full calc embed")
+    targetemb=standard_embed_calc(targetword)
+    print_distances(targetemb)
+
+
+while True:
+    input_text=input("Input a word now:")
+    find_closest(input_text)

openclip/calculate-vith.py

@@ -0,0 +1,94 @@
+#!/bin/env python
+
+""" 
+Plan:
+   Read in "dictionary" for list of words
+   Read in pre-calculated "proper" embedding for each word from safetensor file
+   Prompt user for a word from the list
+   Generate a tensor array of distance to all the other known words
+   Print out the 20 closest ones
+"""
+
+
+import sys
+import torch
+import open_clip
+
+from safetensors import safe_open
+
+#from transformers import CLIPProcessor,CLIPModel
+
+device=torch.device("cuda")
+
+mtype='ViT-H-14'
+mname='laion2b_s32b_b79k'
+
+print("Loading",mtype,mname)
+
+cmodel, _, preprocess = open_clip.create_model_and_transforms(mtype,
+        pretrained=mname)
+tokenizer = open_clip.get_tokenizer(mtype)
+
+## model = model.to(device)
+
+
+#embed_file="embeddings.safetensors"
+embed_file=sys.argv[1]
+dictionary=sys.argv[2]
+
+
+print(f"read in words from {dictionary} now",file=sys.stderr)
+with open(dictionary,"r") as f:
+    tokendict = f.readlines()
+    wordlist = [token.strip() for token in tokendict]  # Remove trailing newlines
+print(len(wordlist),"lines read")
+
+print(f"read in {embed_file} now",file=sys.stderr)
+emodel = safe_open(embed_file,framework="pt",device="cuda")
+embs=emodel.get_tensor("embeddings")
+embs.to(device)
+print("Shape of loaded embeds =",embs.shape)
+
+def standard_embed_calc(text):
+    with torch.no_grad():
+        ttext = tokenizer(text)
+        text_features = cmodel.encode_text(ttext)
+    embedding = text_features[0]
+    #print("shape of text is",ttext.shape)
+    return embedding
+
+
+def print_distances(targetemb):
+    targetdistances = torch.cdist( targetemb.unsqueeze(0), embs, p=2)
+
+    print("shape of distances...",targetdistances.shape)
+
+    smallest_distances, smallest_indices = torch.topk(targetdistances[0], 20, largest=False)
+
+    smallest_distances=smallest_distances.tolist()
+    smallest_indices=smallest_indices.tolist()
+    for d,i in zip(smallest_distances,smallest_indices):
+        print(wordlist[i],"(",d,")")
+
+
+
+# Find 10 closest tokens to targetword.
+# Will include the word itself
+def find_closest(targetword):
+    try:
+        targetindex=wordlist.index(targetword)
+        targetemb=embs[targetindex]
+        print_distances(targetemb)
+        return
+    except ValueError:
+        print(targetword,"not found in cache")
+
+
+    print("Now doing with full calc embed")
+    targetemb=standard_embed_calc(targetword)
+    print_distances(targetemb)
+
+
+while True:
+    input_text=input("Input a word now:")
+    find_closest(input_text)

openclip/embeddings.vith14-quickgelu.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8014c16a1b2b2a971c5d8d8aaf5662d7fa0269d32a46497f5769ae3718f02cc6
+size 134885464

openclip/embeddings.vith14.dictionary.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c55fe6c6300500d9304343b19efb43cb1ccb170270dc8c854def0bedfa576413
+size 134885464

openclip/embeddings.vitl.dictionary.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:240da92c0376aa71385c02b8edcb91ddc75c935d99ae42164ebf3fdab3d6499c
+size 101164120

openclip/generate-embeddings-open.py

@@ -14,25 +14,54 @@ import torch
 import open_clip
 from safetensors.torch import save_file
 
+outfile="out.safetensors"
+
+
+"""
+    REMEMBER!!!
+    You MUST use the same settings when you READ from the output file as well!!
+"""
+
 #mtype='ViT-B-32'
 #mname='laion2b_s34b_b79k'
 #mtype='ViT-g-14'
 #mname='laion2b_s12b_b42k'
-mtype='ViT-H-14'
-mname='laion2b_s32b_b79k'
+#mtype='ViT-H-14'
+#mname='laion2b_s32b_b79k'
+mtype='ViT-L-14'
+mname='laion2b_s32b_b82k'
+#### Warning, this requires more than 4GB vram
+#mtype='ViT-H-14-quickgelu'
+#mname='dfn5b'
+
+# May also be able to use syntax of
+#   hf-hub:hf-internal-testing/tiny-open-clip-model'
+# for mname
 
 print("Loading",mtype,mname)
 
-cmodel, _, preprocess = open_clip.create_model_and_transforms(mtype,
+cmodel, _, preprocess = open_clip.create_model_and_transforms(
+        mtype,
         pretrained=mname)
 tokenizer = open_clip.get_tokenizer(mtype)
 
+device=torch.device("cuda")
+
+try:
+    cmodel.to(device)
+except torch.cuda.OutOfMemoryError as e:
+    print(f"FALLING BACK TO CPU!! \n  {e}")
+    device=torch.device("cpu")
+    cmodel.to(device)
+    # This is very rare... unless you are trying to load the quickgelu sets
+    # on a 4GB card. Or maybe have 2 things running
 
 
 def standard_embed_calc(text):
     with torch.no_grad():
-        ttext = tokenizer(text)
+        ttext = tokenizer(text).to(device)
         text_features = cmodel.encode_text(ttext)
+        text_features.to(device)
     #print("shape of text is",ttext.shape)
 
     embedding = text_features[0]
@@ -60,7 +89,7 @@ for word in tokendict:
 embs = torch.cat(all_embeddings,dim=0)
 print("Shape of result = ",embs.shape)
 print("Saving all the things...")
-save_file({"embeddings": embs}, "embeddings.safetensors")
+save_file({"embeddings": embs}, outfile)
 
 
 print("calculate distances now")