Upload 3 files

description_validator.py

@@ -0,0 +1,65 @@
+from sentence_transformers import SentenceTransformer
+from transformers import AutoTokenizer
+from sklearn.metrics.pairwise import cosine_similarity
+import numpy as np
+
+from warnings import filterwarnings
+filterwarnings("ignore")
+
+models = ["MPNet-base-v2", "DistilRoBERTa-v1", "MiniLM-L12-v2", "MiniLM-L6-v2"]
+models_info = {
+    "MPNet-base-v2": {
+        "model_size": "420MB",
+        "model_url": "sentence-transformers/all-mpnet-base-v2",
+        "efficiency": "Moderate",
+        "chunk_size": 512
+    },
+    "DistilRoBERTa-v1": {
+        "model_size": "263MB",
+        "model_url": "sentence-transformers/all-distilroberta-v1",
+        "efficiency": "High",
+        "chunk_size": 512
+    },
+    "MiniLM-L12-v2": {
+        "model_size": "118MB",
+        "model_url": "sentence-transformers/all-MiniLM-L12-v2",
+        "efficiency": "High",
+        "chunk_size": 512
+    },
+    "MiniLM-L6-v2": {
+        "model_size": "82MB",
+        "model_url": "sentence-transformers/all-MiniLM-L6-v2",
+        "efficiency": "Very High",
+        "chunk_size": 512
+    }
+}
+
+class Description_Validator:
+    def __init__(self, model_name=None):
+        if model_name is None: model_name="DistilRoBERTa-v1"
+        
+        self.model_info     = models_info[model_name]
+        model_url           = self.model_info["model_url"]
+        
+        self.model          = SentenceTransformer(model_url)
+        self.tokenizer      = AutoTokenizer.from_pretrained(model_url)
+        self.chunk_size     = self.model_info["chunk_size"]
+
+    def tokenize_and_chunk(self, text):
+        tokens = self.tokenizer(text, truncation=False, padding=True, add_special_tokens=False)['input_ids']
+        token_chunks = [tokens[i:i+self.chunk_size] for i in range(0, len(tokens), self.chunk_size)]
+        return token_chunks
+
+    def get_average_embedding(self, text):
+        token_chunks = self.tokenize_and_chunk(text)
+        chunk_embeddings = []
+        for chunk in token_chunks:
+            chunk_embedding = self.model.encode(self.tokenizer.decode(chunk), show_progress_bar=False)
+            chunk_embeddings.append(chunk_embedding)
+        return np.mean(chunk_embeddings, axis=0)
+    
+    def similarity_score(self, desc1, desc2):
+        embedding1 = self.get_average_embedding(desc1).reshape(1, -1)
+        embedding2 = self.get_average_embedding(desc2).reshape(1, -1)
+        similarity = cosine_similarity(embedding1, embedding2)
+        return similarity[0][0]

image_validator.py

@@ -0,0 +1,64 @@
+from transformers import CLIPProcessor, CLIPModel, ViTImageProcessor, ViTModel
+from PIL import Image
+from sklearn.metrics.pairwise import cosine_similarity
+
+from warnings import filterwarnings
+filterwarnings("ignore")
+
+models = ["CLIP-ViT Base", "ViT Base", "DINO ViT-S16"]
+models_info = {
+    "CLIP-ViT Base": {
+        "model_size": "386MB",
+        "model_url": "openai/clip-vit-base-patch32",
+        "efficiency": "High",
+    },
+    "ViT Base": {
+        "model_size": "304MB",
+        "model_url": "google/vit-base-patch16-224",
+        "efficiency": "High",
+    },
+    "DINO ViT-S16": {
+        "model_size": "1.34GB",
+        "model_url": "facebook/dino-vits16",
+        "efficiency": "Moderate",
+    },
+}
+
+class Image_Validator:
+    def __init__(self, model_name=None):
+        if model_name is None: model_name="ViT Base"
+        
+        self.model_info = models_info[model_name]
+        model_url       = self.model_info["model_url"]
+        
+        if model_name == "CLIP-ViT Base":
+            self.model              = CLIPModel.from_pretrained(model_url)
+            self.processor          = CLIPProcessor.from_pretrained(model_url)
+            
+        elif model_name == "ViT Base":
+            self.model              = ViTModel.from_pretrained(model_url)
+            self.feature_extractor  = ViTImageProcessor.from_pretrained(model_url)
+            
+        elif model_name == "DINO ViT-S16":
+            self.model              = ViTModel.from_pretrained(model_url)
+            self.feature_extractor  = ViTImageProcessor.from_pretrained(model_url)
+    
+    def get_image_embedding(self, image_path):
+        image = Image.open(image_path)
+        
+        # Process image according to the model
+        if hasattr(self, 'processor'):  # CLIP models
+            inputs  = self.processor(images=image, return_tensors="pt")
+            outputs = self.model.get_image_features(**inputs)
+            
+        elif hasattr(self, 'feature_extractor'):  # ViT models
+            inputs  = self.feature_extractor(images=image, return_tensors="pt")
+            outputs = self.model(**inputs).last_hidden_state
+        
+        return outputs
+    
+    def similarity_score(self, image_path_1, image_path_2):
+        embedding1 = self.get_image_embedding(image_path_1).reshape(1, -1)
+        embedding2 = self.get_image_embedding(image_path_2).reshape(1, -1)
+        similarity = cosine_similarity(embedding1.detach().numpy(), embedding2.detach().numpy())
+        return similarity[0][0]

product_update_validator.py

@@ -0,0 +1,21 @@
+from model_factory.description_validator import Description_Validator
+from model_factory.image_validator import Image_Validator
+
+class Update_Validator:
+    def __init__(self, text_model=None, image_model=None, threshold=0.7):
+        self.description_validator  = Description_Validator(model_name=text_model)
+        self.image_validator        = Image_Validator(model_name=image_model)
+        self.threshold              = threshold
+    
+    def validate(self, text1, text2, image_path_1, image_path_2, threshold=None, return_score=False):
+        description_similarity  = self.description_validator.similarity_score(text1, text2)
+        image_similarity        = self.image_validator.similarity_score(image_path_1, image_path_2)
+        similarity_score        = 0.75 * description_similarity + 0.25 * image_similarity
+        
+        if threshold is None: threshold=self.threshold
+        label = True if similarity_score >= threshold else False
+        
+        if return_score:
+            return {'score':similarity_score, 'label':label}
+        else:
+            return {'label':label}