Enhanced streamlit and uploading in huggingface

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,2 +0,0 @@
-# lookalike-image-finder
- "Look-A-Like Image Finder lets you search for similar images by providing either a text description or an image.

src/app/app.py

@@ -1,16 +1,6 @@
 import homepage
-
-search_option = ['Select an option','Search by text', 'Search by image']
+import streamlit as st
 
 homepage.setup_page()
-
-choosen_option = homepage.get_user_selection(search_option)
-if choosen_option.lower() == 'search by text':
-    user_query = homepage.get_search_text_input()
-    if user_query:
-        homepage.get_images_by_text(user_query)
-elif choosen_option.lower() == 'search by image':
-    image_input = homepage.get_search_image_input()
-    if image_input:
-        homepage.get_images_by_image(image_input)
-
+homepage.search_tab()
+st.link_button("Navigate to load data page",url="http://localhost:8501/load_data_page")

src/app/homepage.py

@@ -4,32 +4,88 @@ src_directory = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..",
 sys.path.append(src_directory)
 import streamlit as st
 from utils import logger
-from database_pinecone import querry_database
+from database_pinecone import querry_database,create_database
 from model.clip_model import ClipModel
+from data import data_set
 
 clip_model = ClipModel()
 logger = logger.get_logger()
 
-PAGE_TITLE = "Look A Like - Image Finder"
-PAGE_LAYOUT = "centered"
+PAGE_TITLE = "Look-a-Like: Image Finder"
+PAGE_LAYOUT = "wide"
 SIDEBAR_TITLE = "Find Similar Images"
+PHOTO_ID_KEY = "photo_id" 
+IMAGE_URL_KEY = "photo_image_url"
+PINECONE_INDEX =  create_database.get_index()
 
 def setup_page():
-    if 'is_page_configured' not in st.session_state:
-        st.set_page_config(page_title=PAGE_TITLE, layout=PAGE_LAYOUT)
-        st.title(PAGE_TITLE)
-        st.sidebar.title(SIDEBAR_TITLE)
-        logger.info(f"Page configured with title '{PAGE_TITLE}', layout '{PAGE_LAYOUT}', and sidebar title '{SIDEBAR_TITLE}'")
-        st.session_state.is_page_configured = True
-    else:
-        logger.info("Page configuration already completed. Skipping setup.")
+    st.set_page_config(page_title=PAGE_TITLE, layout=PAGE_LAYOUT)
+    st.markdown(f"""
+        <h1 style='color:darkblue; text-align:center; font-size:32px; margin-top:-10px;'>
+        <i>{PAGE_TITLE} 🔍📸</i>
+        </h1>
+        """, unsafe_allow_html=True)
+    st.toast("✨ Welcome to Look-a-Like: The Ultimate Image Finder! Start searching now. 🔍")
+    logger.info(f"Page successfully configured with title: {PAGE_TITLE}")
 
+def search_tab():
+
+    st.markdown("<hr>", unsafe_allow_html=True)  # To add a Horizontal line below title
+
+    if "search_query" not in st.session_state:
+        st.session_state.search_query = ""
+    if "uploaded_image" not in st.session_state:
+        st.session_state.uploaded_image = None
+
+    with st.container():
+
+        col1, col2 = st.columns([7, 4], gap="small")
+        with col1:
+            search_query = st.text_input(
+                label="🔍 Search for Images",
+                placeholder="Type keywords (e.g., 'sunset beach', 'city skyline')",
+                value=st.session_state.search_query
+            )
+
+            if search_query.strip() and search_query != st.session_state.search_query:
+                st.session_state.search_query = search_query.strip()
+                st.session_state.uploaded_image = None 
+
+        with col2:
+            uploaded_image = st.file_uploader(
+                label="📤 Upload an Image",
+                type=["png", "jpg", "jpeg"],
+                help="Upload an image to find visually similar results."
+            )
+
+            if uploaded_image is not None and uploaded_image != st.session_state.uploaded_image:
+                st.session_state.uploaded_image = uploaded_image
+                st.session_state.search_query = "" 
+
+        # with col3:
+        #     st.markdown("<br>", unsafe_allow_html=True)
+        #     if st.button(label="🗑️ Clear", help="Clear search input and uploaded image"):
+        #         st.session_state.search_query = ""
+        #         st.session_state.uploaded_image = None
+        #         st.session_state.clear()
+
+    with st.container():
+        if st.session_state.search_query:
+            get_images_by_text(st.session_state.search_query)
+            st.session_state.search_query = "" 
+
+
+        if st.session_state.uploaded_image:
+            st.image(st.session_state.uploaded_image, caption="Uploaded Image", use_container_width=True)
+            get_images_by_image(st.session_state.uploaded_image)
+            st.session_state.uploaded_image = None
+    
 def get_user_selection(options):
     selected_option = st.sidebar.selectbox("Select the option", options)
     return selected_option
 
 def get_search_image_input():
-    uploaded_image = st.sidebar.file_uploader("Upload the image to get similar images", type=['png', 'jpeg'])
+    uploaded_image = st.file_uploader("Upload the image to get similar images", type=['png', 'jpeg'])
     return uploaded_image
 
 def get_search_text_input():
@@ -37,11 +93,13 @@ def get_search_text_input():
     return user_search
 
 def display_images(response):
+    logger.info("Loading the images to dispay")
     if response:
         cols = st.columns(2)
         for i, result in enumerate(response.matches):
             with cols[i % 2]:
-                st.image(result.metadata["url"])
+                st.image(result.metadata["url"], width=500)
+        logger.info("Displayed the images successfully")
 
 def write_message(message):
     st.write(message)
@@ -49,13 +107,71 @@ def write_message(message):
 def get_images_by_text(query):
     embedding = clip_model.get_text_embedding(query)
     response = querry_database.fetch_data(embedding)
-    message = f"Showing search results for {query}"
+    message = f"🔍 Showing search results for {query}"
     write_message(message)
     images = display_images(response)
 
 def get_images_by_image(query):
     embedding = clip_model.get_uploaded_image_embedding(query)
     response = querry_database.fetch_data(embedding)
-    message = f"Showing search results of relevant images"
+    message = f"🔍 Showing search results of relevant images"
     write_message(message)
     images = display_images(response)
+
+def load_data():
+    st.sidebar.header("📊 Data Loading Parameters")
+    start_index  = st.sidebar.number_input("Select start index", min_value=0, value=0)
+    end_index  = st.sidebar.number_input("Select end index", min_value=0, value=100)
+
+    if start_index > end_index:
+        st.sidebar.error("⚠️ Start index must be earlier than the end index.")
+        return
+    
+    if "load_clicked" not in st.session_state:
+        st.session_state.load_clicked = False
+
+    try:
+        st.sidebar.info(f"Click the button to load data from index **{start_index} to {end_index}**.")
+        if st.sidebar.button("🚀 Upsert Data", disabled=st.session_state.load_clicked, help="Click to insert data into the database"):
+            st.session_state.load_clicked = True
+
+            with st.spinner("⏳ Upserting data... Please wait"):
+                df = data_set.get_df(start_index, end_index)
+                if df.empty:
+                    st.warning("⚠️ No data found in the selected range.")
+                    return
+                success_message = st.empty()
+                progress_bar = st.progress(0)
+                start = 0
+                end = len(df)
+                for i, data in df.iterrows():
+                    create_database.process_and_upsert_data(PINECONE_INDEX, data, IMAGE_URL_KEY, PHOTO_ID_KEY)
+                    success_message.success(f"Row {i + 1} (ID: {data.get('photo_id', 'unknown')}) added successfully!")
+                    logger.info(f"Row {i + 1} (ID: {data.get('photo_id', 'unknown')}) upserted successfully.")
+                    start = start + 1
+                    progress = int((start) / end * 100)
+                    progress_bar.progress(progress)
+                progress_bar.empty()
+                success_message.success("All data loaded and added to the database successfully!")
+                st.session_state.load_clicked = False
+                st.rerun()
+
+    except Exception as e:
+        st.error(f"Error loading data: {e}")
+        logger.error(f"Error loading data: {e}")
+        st.session_state.load_clicked = False
+
+
+def about_us():
+    if st.button("About us"):
+        st.write("""
+            This app allows you to search for images in two powerful ways:
+    
+            1. **Text-based Query**: You can simply type a description or keyword, and we will fetch the most relevant images from our database.
+    
+            2. **Image-based Query**: Alternatively, you can upload an image, and we'll search for similar images based on your input image.
+
+            Whether you're looking for images based on a specific text query or searching using an image, our app makes it easy to find exactly what you're looking for. Simply enter your query and get results instantly!
+
+            Explore and discover the images you need. Enjoy the search experience! 😊
+            """)

src/app/pages/load_data_page.py

@@ -0,0 +1,5 @@
+import homepage
+
+homepage.setup_page()
+homepage.load_data()
+

src/database_pinecone/create_database.py

@@ -5,10 +5,9 @@ sys.path.append(src_directory)
 from pinecone import Pinecone, ServerlessSpec
 import time
 from model.clip_model import ClipModel
-from data import request_images
-from data import data_set
 from config import config
 from utils import logger
+import pandas as pd
 
 config = config.load_config()
 logger = logger.get_logger()
@@ -57,38 +56,44 @@ def get_index():
         logger.info(f"Error occurred while getting or creating the Pinecone index: {str(e)}", exc_info=True)
         return index
     
-def upsert_data(index,embeddings,id,url):
-    try :
-        logger.info("Started to upsert the data")
+def process_and_upsert_data(index, data: pd.Series, url_key: str, id_key: str):
+    """
+    Processes a single row of data (pandas Series) by extracting the URL and ID, generating image embeddings using 
+    a clip model, and then upserting the generated embeddings into a pinecone database index.
+
+    This function handles:
+    - Extracting the URL and ID from the provided `data` (a pandas Series) using the specified keys (`url_key` and `id_key`).
+    - Using the `clip_model` to generate embeddings for the image found at the extracted URL.
+    - Upserting the generated embeddings, along with the photo ID and URL, into the pinecone database index using the `upsert` method.
+
+    Args:
+        data (pandas.Series): A single row of data from the DataFrame, containing the URL and ID.
+        url_key (str): The column name in the Series that contains the URL of the image.
+        id_key (str): The column name in the Series that contains the photo ID.
+
+    """
+    # Validate if the required columns exist in the row (Series)
+    if url_key not in data or id_key not in data:
+        raise ValueError(f"Missing required keys: '{url_key}' or '{id_key}' in the data")
+
+    try:
+        logger.info("Started to process and upsert the data")
+        url = data[url_key]
+        photo_id = data[id_key]
+        embeddings = clip_model.get_image_embedding(url)
         index.upsert(
             vectors=[{
-                "id": id,
+                "id": photo_id,
                 "values": embeddings,
                 "metadata": {
-                "url": url,
-                "photo_id": id
+                    "url": url,
+                    "photo_id": photo_id
                 }
             }],
             namespace="image-search-dataset",
         )
-        logger.info(f"Successfully upserted the data in database")
+        logger.info(f"Successfully upserted data for photo_id {photo_id} with URL {url}")
+    except ValueError as ve:
+        logger.error(f"ValueError: {ve}")
     except Exception as e:
-        logger.info(f"Unable to upsert the data {e}")
-        raise
-    
-def add_data_to_database(df):
-    try:
-        index = get_index()
-        logger.info("Starting to add the embeddings to the database")
-        for _, data in df.iterrows():
-            url = data['photo_image_url']
-            id = data['photo_id']
-            embeddings = clip_model.get_image_embedding(url)
-            upsert_data(index,embeddings,id,url)
-        logger.info("Added embeddings to the database successfully")
-    except Exception as e:
-        logger.info("Unable to add the data. Error : {e}")
-
-
-# df = data_set.get_df(8000,8500)     
-# add_data_to_database(df)
+        logger.error(f"Error processing row with photo_id {data.get(id_key, 'unknown')}: {e}")