First upload of the code to the repo of CLIP_Text_Embeddings.

Dockerfile

@@ -0,0 +1,26 @@
+# Use an official Python runtime as the base image
+FROM pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime AS base
+
+# It is necessary to install git to run the pip install -r requirements.txt
+RUN apt-get update && apt-get install -y git
+
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+# Set the working directory in the container
+WORKDIR $HOME/app
+
+# Copy the current directory contents into the container at /app
+COPY --chown=user . $HOME/app
+
+RUN pip install -r requirements.txt
+
+FROM base AS debug
+
+CMD ["python", "-m", "pdb", "test_search_engine_model.py"]
+
+FROM base AS run
+
+CMD ["python", "app.py"]

README.md

@@ -1,11 +1,11 @@
 ---
-title: CLIP Text Embeddings
-emoji: 🏢
-colorFrom: purple
-colorTo: purple
+title: CLIP Embeddings
+emoji: 👀
+colorFrom: pink
+colorTo: yellow
 sdk: docker
 pinned: false
-short_description: '  Obtain the embeddings of a given text'
+short_description: Image embeddings extractor using the OpenAI CLIP model
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,51 @@
+import configparser
+import gradio as gr
+import numpy as np
+import pandas as pd
+from search_engine_model import SearchEngineModel
+
+def get_text_embeddings(text_prompt, input_np_array):
+    search_engine_model = SearchEngineModel()
+
+    model, _ = search_engine_model.load_clip_model()
+    text_embeddings = search_engine_model.encode_text(model, text_prompt)
+    
+    input_df = pd.DataFrame(input_np_array)
+    search_result = search_engine_model.search_image_by_text_prompt(text_embeddings, input_df)
+    
+    return text_embeddings, search_result
+
+def main():
+    config_manager_obj = configparser.ConfigParser()
+    config_manager_obj.read('./config.cfg')
+    
+    random_features = np.random.rand(50, 512)
+    initial_dataframe = pd.DataFrame(random_features)
+    names_column = [f'image_{it}.png' for it in range(0, len(random_features))]
+    initial_dataframe.insert(0, 'images_names', names_column)
+
+    main_app = gr.Interface(
+        fn=get_text_embeddings,
+        inputs=[
+            gr.Textbox(),
+            gr.Dataframe(
+                initial_dataframe.values,
+                headers = ["image_name"] + [f'feature_{it}'for it in range(0, random_features.shape[1])],
+                type='numpy', 
+                interactive=False
+            )
+        ],
+        outputs=[
+            gr.Dataframe(type='numpy', headers = [f'feature_{it}'for it in range(0, random_features.shape[1])]),
+            gr.Dataframe(type='numpy', headers = ['image_name', 'similarity'])
+        ],
+        title="CLIP Text Embeddings",
+        description="Obtain the embeddings of a given text and use the API to compare with a set of images' embeddings.",
+        flagging_mode="never"
+    )
+
+    HOST_IP_ADDRESS = config_manager_obj['SERVER']['HOST_IP_ADDRESS']
+    PORT_NUMBER = int(config_manager_obj['SERVER']['PORT_NUMBER'])
+    main_app.launch(server_name=HOST_IP_ADDRESS, server_port=PORT_NUMBER)
+
+main()

config.cfg

@@ -0,0 +1,3 @@
+[SERVER]
+HOST_IP_ADDRESS = 0.0.0.0
+PORT_NUMBER = 7860

requirements.txt

@@ -0,0 +1,3 @@
+gradio==5.12.0
+pandas==2.2.3
+git+https://github.com/openai/CLIP.git@dcba3cb2e2827b402d2701e7e1c7d9fed8a20ef1

search_engine_model.py

@@ -0,0 +1,66 @@
+import clip
+import logging
+import os
+import pandas as pd
+from PIL import Image
+import random
+import torch
+
+class SearchEngineModel():
+
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        logging.basicConfig(level=logging.INFO)
+
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model, self.preprocess = self.load_clip_model()
+
+    def load_clip_model(self):
+        model, preprocess = clip.load("ViT-B/32", device=self.device)
+
+        return model, preprocess
+
+    def read_image(self, image_path):
+        pil_image = Image.open(image_path)
+
+        return pil_image
+
+    def encode_text(self, model, text_prompt):
+        query = clip.tokenize([text_prompt]).to(self.device)
+        with torch.no_grad():
+            text_features = self.model.encode_text(query)
+            text_features = text_features.numpy()
+
+        return text_features
+
+    def __search_image_auxiliar_func__(self, prompt_features, nofimages_to_show):
+        encoded_images, image_paths = self.encode_images(self.model, self.preprocess, self.image_root_dir, self.csv_file_path)
+        similarity = encoded_images @ prompt_features.T
+        values, indices = similarity.topk(nofimages_to_show, dim=0)
+        
+        results = []
+        for value, index in zip(values, indices):
+            results.append(image_paths[index])
+
+        return results
+
+    def search_image_by_text_prompt(self, text_features, images_features):
+        names_column = images_features.values[:, 0]
+        search_results = images_features.values[:, 1:].astype(float) @ text_features.T
+
+        search_results_df = pd.DataFrame(search_results)
+        search_results_df.insert(0, "images_names", names_column)
+        search_results_df.columns = ['images_names', 'similarity']
+        search_results_df = search_results_df.sort_values(by='similarity')
+        search_results = search_results_df.values
+
+        return search_results
+
+    def search_image_by_image_prompt(self, image_prompt, nofimages_to_show):
+        image = self.preprocess(image_prompt).unsqueeze(0).to(self.device)
+        with torch.no_grad():
+            image_features = self.model.encode_image(image)
+
+        search_results = self.__search_image_auxiliar_func__(image_features, nofimages_to_show)
+
+        return search_results

test_search_engine_model.py

@@ -0,0 +1,18 @@
+import numpy as np
+import pandas as pd
+from search_engine_model import SearchEngineModel
+
+def main():
+    search_engine_model = SearchEngineModel()
+    model, preprocess = search_engine_model.load_clip_model()
+    text_prompt = 'cat'
+    text_embeddings = search_engine_model.encode_text(model, text_prompt)
+
+    random_features = np.random.rand(50, 512)
+    input_df = pd.DataFrame(random_features)
+    names_column = [f'image_{it}.png' for it in range(0, len(random_features))]
+    input_df.insert(0, 'images_names', names_column)
+
+    search_result = search_engine_model.search_image_by_text_prompt(text_embeddings, input_df)
+
+main()