Upload app.py

src/app.py

@@ -0,0 +1,282 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import re
+
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sentence_transformers import SentenceTransformer
+from rank_bm25 import BM25Okapi
+from rapidfuzz import fuzz
+import faiss
+import nltk
+
+# ==============================
+# FIX NLTK (HUGGINGFACE SAFE)
+# ==============================
+nltk.download('wordnet', quiet=True)
+from nltk.corpus import wordnet
+
+# ==============================
+# PAGE CONFIG
+# ==============================
+st.set_page_config(page_title="Multi Search Engine", layout="wide")
+st.title("🔍 Advanced Multi-Search Product Engine")
+
+# ==============================
+# LOAD MODEL (NO CACHE BUG)
+# ==============================
+if "model" not in st.session_state:
+    with st.spinner("Loading AI model..."):
+        st.session_state.model = SentenceTransformer(
+            'all-MiniLM-L6-v2',
+            device='cpu'
+        )
+
+model = st.session_state.model
+
+# ==============================
+# SEARCH INFO
+# ==============================
+search_info = {
+    "Keyword": ("Find exact word match", "iphone → iPhone"),
+    "Regex": ("Pattern-based search", "^S → Samsung"),
+    "Boolean": ("Use AND / OR", "nike AND shoes"),
+    "Fuzzy": ("Handles spelling mistakes", "iphon → iPhone"),
+    "N-Gram": ("Partial word match", "iph → iPhone"),
+    "Prefix": ("Starts with query", "app → Apple"),
+    "Suffix": ("Ends with query", "laptop → Dell Laptop"),
+    "TF-IDF": ("Ranks important words", "wireless headphones"),
+    "BM25": ("Advanced keyword ranking", "gaming laptop"),
+    "Semantic": ("Understands meaning", "sports footwear"),
+    "FAISS": ("Fast semantic search", "music device"),
+    "Hybrid": ("Keyword + meaning", "sports shoes"),
+    "Query Expansion": ("Adds similar words", "speaker → audio"),
+    "Weighted Hybrid": ("Weighted ranking", "better accuracy"),
+    "Ensemble": ("Combine all methods", "best results")
+}
+
+# ==============================
+# CACHE PREPROCESSING (STABLE)
+# ==============================
+@st.cache(allow_output_mutation=True)
+def preprocess_data(products):
+
+    # TF-IDF
+    tfidf = TfidfVectorizer()
+    tfidf_matrix = tfidf.fit_transform(products)
+
+    # Embeddings (NO progress bar → HF fix)
+    embeddings = model.encode(products, batch_size=64, show_progress_bar=False)
+
+    # Normalize for FAISS
+    faiss.normalize_L2(embeddings)
+
+    # FAISS index
+    dim = embeddings.shape[1]
+    index = faiss.IndexFlatIP(dim)
+    index.add(np.array(embeddings))
+
+    # BM25
+    tokenized = [p.split() for p in products]
+    bm25 = BM25Okapi(tokenized)
+
+    return tfidf, tfidf_matrix, embeddings, index, bm25
+
+
+@st.cache(allow_output_mutation=True)
+def get_synonyms(word):
+    synonyms = set()
+    for syn in wordnet.synsets(word):
+        for lemma in syn.lemmas():
+            synonyms.add(lemma.name())
+    return synonyms
+
+# ==============================
+# FILE LOAD
+# ==============================
+uploaded_file = st.file_uploader("Upload CSV", type=["csv"])
+
+if uploaded_file:
+    df = pd.read_csv(uploaded_file)
+else:
+    st.info("Using sample dataset")
+    df = pd.DataFrame({
+        "product_name": [
+            "iPhone 14 Pro",
+            "Samsung Galaxy S23",
+            "Nike Running Shoes",
+            "Dell Gaming Laptop",
+            "Bluetooth Speaker"
+        ],
+        "category": ["Mobile", "Mobile", "Footwear", "Laptop", "Electronics"],
+        "brand": ["Apple", "Samsung", "Nike", "Dell", "JBL"],
+        "description": [
+            "Latest smartphone",
+            "Android flagship phone",
+            "Comfort sports shoes",
+            "High performance laptop",
+            "Portable music device"
+        ]
+    })
+
+st.subheader("📄 Data Preview")
+st.dataframe(df.head())
+
+# ==============================
+# COMBINE TEXT
+# ==============================
+df["combined"] = (
+    df["product_name"].astype(str) + " " +
+    df["category"].astype(str) + " " +
+    df["brand"].astype(str) + " " +
+    df["description"].astype(str)
+)
+
+products = df["combined"].tolist()
+
+# ==============================
+# PREPROCESS (ONLY ONCE)
+# ==============================
+with st.spinner("Processing data..."):
+    tfidf, tfidf_matrix, embeddings, index, bm25 = preprocess_data(products)
+
+# ==============================
+# SEARCH FUNCTIONS
+# ==============================
+def keyword_search(q):
+    return [(i, 1) for i, p in enumerate(products) if q.lower() in p.lower()]
+
+def regex_search(q):
+    return [(i, 1) for i, p in enumerate(products) if re.search(q, p, re.IGNORECASE)]
+
+def boolean_search(q):
+    if "AND" in q:
+        terms = q.split("AND")
+        return [(i, 1) for i, p in enumerate(products)
+                if all(t.strip().lower() in p.lower() for t in terms)]
+    elif "OR" in q:
+        terms = q.split("OR")
+        return [(i, 1) for i, p in enumerate(products)
+                if any(t.strip().lower() in p.lower() for t in terms)]
+    return []
+
+def fuzzy_search(q):
+    scores = [(i, fuzz.ratio(q, p)) for i, p in enumerate(products)]
+    return sorted(scores, key=lambda x: x[1], reverse=True)[:10]
+
+def ngram_search(q):
+    return [(i, 1) for i, p in enumerate(products) if q[:3].lower() in p.lower()]
+
+def prefix_search(q):
+    return [(i, 1) for i, p in enumerate(products) if p.lower().startswith(q.lower())]
+
+def suffix_search(q):
+    return [(i, 1) for i, p in enumerate(products) if p.lower().endswith(q.lower())]
+
+def tfidf_search(q):
+    q_vec = tfidf.transform([q])
+    scores = (tfidf_matrix @ q_vec.T).toarray().flatten()
+    idx = np.argsort(scores)[::-1][:10]
+    return [(i, float(scores[i])) for i in idx]
+
+def bm25_search(q):
+    scores = bm25.get_scores(q.split())
+    idx = np.argsort(scores)[::-1][:10]
+    return [(i, float(scores[i])) for i in idx]
+
+def semantic_search(q):
+    q_emb = model.encode([q], show_progress_bar=False)
+    faiss.normalize_L2(q_emb)
+    scores = np.dot(embeddings, q_emb.T).flatten()
+    idx = np.argsort(scores)[::-1][:10]
+    return [(i, float(scores[i])) for i in idx]
+
+def faiss_search(q):
+    q_emb = model.encode([q], show_progress_bar=False)
+    faiss.normalize_L2(q_emb)
+    D, I = index.search(np.array(q_emb), 10)
+    return [(i, float(D[0][idx])) for idx, i in enumerate(I[0])]
+
+def hybrid_search(q):
+    tfidf_res = dict(tfidf_search(q))
+    sem_res = dict(semantic_search(q))
+    combined = {i: tfidf_res.get(i, 0) + sem_res.get(i, 0) for i in range(len(products))}
+    return sorted(combined.items(), key=lambda x: x[1], reverse=True)[:10]
+
+def query_expansion_search(q):
+    synonyms = get_synonyms(q)
+    expanded_query = q + " " + " ".join(synonyms)
+    return tfidf_search(expanded_query)
+
+def weighted_hybrid(q):
+    tfidf_res = dict(tfidf_search(q))
+    sem_res = dict(semantic_search(q))
+    bm25_res = dict(bm25_search(q))
+
+    combined = {}
+    for i in range(len(products)):
+        combined[i] = (
+            0.4 * tfidf_res.get(i, 0) +
+            0.4 * sem_res.get(i, 0) +
+            0.2 * bm25_res.get(i, 0)
+        )
+    return sorted(combined.items(), key=lambda x: x[1], reverse=True)[:10]
+
+def ensemble_search(q):
+    results = {}
+    for func in [tfidf_search, semantic_search, bm25_search]:
+        for i, score in func(q):
+            results[i] = results.get(i, 0) + score
+    return sorted(results.items(), key=lambda x: x[1], reverse=True)[:10]
+
+# ==============================
+# UI
+# ==============================
+search_type = st.selectbox("Select Search Type", list(search_info.keys()))
+
+explanation, example = search_info[search_type]
+
+st.markdown(f"""
+### 🔍 {search_type} Search
+- **Explanation:** {explanation}
+- **Example:** `{example}`
+""")
+
+query = st.text_input("Enter your search query")
+
+if st.button("Try Example"):
+    query = example.split("→")[0].strip()
+    st.success(f"Example loaded: {query}")
+
+top_k = st.slider("Top Results", 5, 20, 10)
+
+if st.button("Search"):
+    if not query:
+        st.warning("Enter query")
+    else:
+        func_map = {
+            "Keyword": keyword_search,
+            "Regex": regex_search,
+            "Boolean": boolean_search,
+            "Fuzzy": fuzzy_search,
+            "N-Gram": ngram_search,
+            "Prefix": prefix_search,
+            "Suffix": suffix_search,
+            "TF-IDF": tfidf_search,
+            "BM25": bm25_search,
+            "Semantic": semantic_search,
+            "FAISS": faiss_search,
+            "Hybrid": hybrid_search,
+            "Query Expansion": query_expansion_search,
+            "Weighted Hybrid": weighted_hybrid,
+            "Ensemble": ensemble_search
+        }
+
+        results = func_map[search_type](query)[:top_k]
+
+        indices = [i for i, _ in results]
+        result_df = df.iloc[indices].copy()
+        result_df["Score"] = [score for _, score in results]
+
+        st.subheader("🔎 Results")
+        st.dataframe(result_df)