File size: 7,166 Bytes
3bb0526 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 |
from pinecone_text.sparse import SpladeEncoder
import re
import torch
import torch.nn.functional as F
from transformers import CLIPModel, CLIPProcessor, CLIPTokenizer
import logging
class EmbeddingModels:
def __init__(self, device="cuda" if torch.cuda.is_available() else "cpu"):
self.device = device
logging.info(f'Using Device {self.device}')
self.sparse_model = SpladeEncoder(device=self.device)
self.img_model_ID = "openai/clip-vit-large-patch14"
self.img_model, self.img_processor, self.img_tokenizer = self.get_image_model_info(self.img_model_ID)
logging.info("Model Loaded")
def get_image_model_info(self, model_ID):
model = CLIPModel.from_pretrained(model_ID).to(self.device)
processor = CLIPProcessor.from_pretrained(model_ID)
tokenizer = CLIPTokenizer.from_pretrained(model_ID)
return model, processor, tokenizer
def get_single_image_embedding(self, my_image):
image = self.img_processor(
text=None,
images=my_image,
return_tensors="pt"
)["pixel_values"].to(self.device)
embedding = self.img_model.get_image_features(image)
logging.info("Embeddings Created")
embeddings = F.normalize(embedding, p=2, dim=1)
logging.info("Embeddings Normalized")
values = embeddings[0].tolist()
return values
def preprocessing_patent_data(self,text):
# Removing Common tags in patent
pattern0 = r'\b(SUBSTITUTE SHEET RULE 2 SUMMARY OF THE INVENTION|BRIEF DESCRIPTION OF PREFERRED EMBODIMENTS|BRIEF DESCRIPTION OF THE DRAWINGS/FIGURES|BEST MODE FOR CARRYING OUT THE INVENTION|BACKGROUND AND SUMMARY OF THE INVENTION|FIELD AND BACKGROUND OF THE INVENTION|BACKGROUND OF THE PRESENT INVENTION|FIELD AND BACKGROUND OF INVENTION|STAND DER TECHNIK- BACKGROUND ART|BRIEF DESCRIPTION OF THE DRAWINGS|DESCRIPTION OF THE RELATED ART|BRIEF SUMMARY OF THE INVENTION|UTILITY MODEL CLAIMS A CONTENT|DESCRIPTION OF BACKGROUND ART|BRIEF DESCRIPTION OF DRAWINGS|BACKGROUND OF THE INVENTION|BACKGROUND TO THE INVENTION|TÉCNICA ANTERIOR- PRIOR ART|DISCLOSURE OF THE INVENTION|BRIEF SUMMARY OF INVENTION|BACKGROUND OF RELATED ART|SUMMARY OF THE DISCLOSURE|SUMMARY OF THE INVENTIONS|SUMMARY OF THE INVENTION|OBJECTS OF THE INVENTION|THE CONTENT OF INVENTION|DISCLOSURE OF INVENTION|Disclosure of Invention|Complete Specification|RELATED BACKGROUND ART|BACKGROUND INFORMATION|BACKGROUND TECHNOLOGY|DETAILED DESCRIPTION|SUMMARY OF INVENTION|DETAILED DESCRIPTION|PROBLEM TO BE SOLVED|EFFECT OF INVENTION|WHAT IS CLAIMED IS|What is claimed is|What is Claim is|SUBSTITUTE SHEET|SELECTED DRAWING|BACK GROUND ART|BACKGROUND ART|Background Art|JPO&INPIT|CONSTITUTION|DEFINITIONS|Related Art|BACKGROUND|JPO&INPIT|JPO&NCIPI|COPYRIGHT|SOLUTION|SUMMARY)\b'
text = re.sub(pattern0, '[SEP]', text, flags=re.IGNORECASE)
text = ' '.join(text.split())
# Removing all tags between Heading to /Heading and id=
regex = r'<\s*heading[^>]*>(.*?)<\s*/\s*heading>|<[^<]+>|id=\"p-\d+\"|:'
result = re.sub(regex, '[SEP]', text, flags=re.IGNORECASE)
# find_formula_names from pat text to exclude it from below logic regex
chemical_list = []
pattern1 = r'\b((?:(?:H|He|Li|Be|B|C|N|O|F|Ne|Na|Mg|Al|Si|P|S|Cl|Ar|K|Ca|Sc|Ti|V|Cr|Mn|Fe|Co|Ni|Cu|Zn|Ga|Ge|As|Se|Br|Kr|Rb|Sr|Y|Zr|Nb|Mo|Tc|Ru|Rh|Pd|Ag|Cd|In|Sn|Sb|Te|I|Xe|Cs|Ba|La|Hf|Ta|W|Re|Os|Ir|Pt|Au|Hg|Tl|Pb|Bi|Po|At|Rn|Fr|Ra|Ac|Rf|Db|Sg|Bh|Hs|Mt|Ds|Rg|Cn|Nh|Fl|Mc|Lv|Ts|Og|Ce|Pr|Nd|Pm|Sm|Eu|Gd|Tb|Dy|Ho|Er|Tm|Yb|Lu|Th|Pa|U|Np|Pu|Am|Cm|Bk|Cf|Es|Fm|Md|No|Lr)\d*)+)\b'
formula_names = re.findall(pattern1, result)
for formula in formula_names:
if len(formula)>=2:
chemical_list.append(formula)
# print("chemical_list:", chemical_list)
# Remove numbers and alphanum inside brackets excluding chemical forms
pattern2 = r"\((?![A-Za-z]+\))[\w\d\s,-]+\)|\([A-Za-z]\)"
def keep_strings(text):
matched = text.group(0)
if any(item in matched for item in chemical_list):
return matched
return ' '
cleaned_text = re.sub(pattern2, keep_strings, result)
cleaned_text = ' '.join(cleaned_text.split())
cleaned_text= re.sub("(\[SEP\]+\s*)+", ' ', cleaned_text, flags=re.IGNORECASE)
# below new logic to remove chemical compounds (eg.chemical- polymerizable compounds)
p_text2=re.sub('[\—\-\═\=]', ' ', cleaned_text)
pattern1 = r'\b((?:(?:H|He|Li|Be|B|C|N|O|F|Ne|Na|Mg|Al|Si|P|S|Cl|Ar|K|Ca|Sc|Ti|V|Cr|Mn|Fe|Co|Ni|Cu|Zn|Ga|Ge|As|Se|Br|Kr|Rb|Sr|Y|Zr|Nb|Mo|Tc|Ru|Rh|Pd|Ag|Cd|In|Sn|Sb|Te|I|Xe|Cs|Ba|La|Hf|Ta|W|Re|Os|Ir|Pt|Au|Hg|Tl|Pb|Bi|Po|At|Rn|Fr|Ra|Ac|Rf|Db|Sg|Bh|Hs|Mt|Ds|Rg|Cn|Nh|Fl|Mc|Lv|Ts|Og|Ce|Pr|Nd|Pm|Sm|Eu|Gd|Tb|Dy|Ho|Er|Tm|Yb|Lu|Th|Pa|U|Np|Pu|Am|Cm|Bk|Cf|Es|Fm|Md|No|Lr)\d*)+)\b'
cleaned_text = re.sub(pattern1, "", p_text2)
cleaned_text = re.sub(' ,+|, +', ' ', cleaned_text)
cleaned_text = re.sub(' +', ' ', cleaned_text)
cleaned_text = re.sub('\.+', '.', cleaned_text)
cleaned_text = re.sub('[0-9] [0-9] +', ' ', cleaned_text)
cleaned_text = re.sub('( )', ' ', cleaned_text)
cleaned_text=cleaned_text.strip()
return cleaned_text
def get_single_sparse_text_embedding(self, df_chunk):
df_chunk = self.preprocessing_patent_data(df_chunk)
txt_sp = self.sparse_model.encode_documents(df_chunk)
# tensor = torch.tensor(txt_sp['values'])
# normalized_tensor = F.normalize(tensor, p=2.0, dim=0, eps=1e-12)
# values = normalized_tensor.tolist()
# # Update the sparse_vector with normalized values
# normalized_sparse_vector = {
# 'indices': txt_sp['indices'],
# 'values': values
# }
return txt_sp
def normalize_sparse_vector_values(self,sparse_vector):
"""
Normalize the values of a sparse vector to a 0-1 range using min-max scaling,
considering a known range of sparse scores.
Args:
sparse_vector: A dict representing a sparse vector with 'indices' and 'values'
min_score: The minimum score in the range of sparse scores (default is 0)
max_score: The maximum score in the range of sparse scores (default is 6000)
Returns:
A dict representing the sparse vector with normalized 'values'.
"""
# normalized_values = [(value - min_score) / (max_score - min_score) for value in sparse_vector['values']]
self.tensor = torch.tensor(sparse_vector['values'])
self.normalized_tensor = F.normalize(self.tensor, p=2.0, dim=0, eps=1e-12)
values = self.normalized_tensor.tolist()
# Update the sparse_vector with normalized values
self.normalized_sparse_vector = {
'indices': sparse_vector['indices'],
'values': values
}
return self.normalized_sparse_vector
|