Upload 11 files

.gitattributes

@@ -1,35 +1,2 @@
-*.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
+*.psd filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,46 @@
----
-title: Recommendation System
-emoji: ⚡
-colorFrom: purple
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.36.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Gen-AI-based-fashion-product-recommendation-system
+Fashion Recommender System with Chatbot Integration This project implements a Fashion Recommender System using state-of-the-art machine learning models and a chatbot interface. The system recommends fashion products based on uploaded images and responds to user queries through a chat interface.
+
+Technologies Used:
+
+Streamlit: For building the user interface and dashboard.
+
+TensorFlow: Utilized for image feature extraction and recommendation.
+
+Sentence Transformers: Used for text embeddings and similarity calculations.
+
+Hugging Face Transformers: Integrated for natural language processing tasks.
+
+MySQL Connector: For user authentication and database operations.
+
+PIL (Python Imaging Library): Used for image processing tasks.
+
+scikit-learn: Employed for nearest neighbor search for recommendation.
+
+PyTorch: Utilized for text and image embeddings.
+
+Matplotlib: Used for displaying images and visualizations.
+
+Key Features:
+
+Login and Registration: Users can authenticate themselves before accessing the system.
+
+Image Upload and Recommendation: Users can upload images of fashion products, and the system provides recommendations based on image similarity.
+
+Chatbot Integration: Includes a chatbot interface that responds to user queries and provides additional product information.
+
+Dashboard: Provides a user-friendly dashboard for navigation and interaction with the system.
+
+Usage:
+
+Clone the repository.
+
+Install the required dependencies using pip install -r requirements.txt.
+
+Run the application using streamlit run main.py.
+
+Access the application through the provided URL.
+
+Note:
+
+This project is a prototype and may require additional enhancements for production use. Contributions and feedback are welcome!

app.py

@@ -0,0 +1,54 @@
+import tensorflow
+from tensorflow.keras.preprocessing import image
+from tensorflow.keras.layers import GlobalMaxPooling2D
+from tensorflow.keras.applications.resnet50 import ResNet50,preprocess_input
+import numpy as np
+from numpy.linalg import norm
+import os
+from tqdm import tqdm
+import pickle
+
+# Load pre-trained ResNet50 model
+
+model = ResNet50(weights='imagenet',include_top=False,input_shape=(224,224,3))
+model.trainable = False
+
+# Create a Sequential model with ResNet50 as base and GlobalMaxPooling2D layer
+
+model = tensorflow.keras.Sequential([
+    model,
+    GlobalMaxPooling2D()
+])
+
+#print(model.summary())
+
+# Function to extract features from an image using the model
+def extract_features(img_path,model):
+    img = image.load_img(img_path,target_size=(224,224))
+    img_array = image.img_to_array(img)
+    expanded_img_array = np.expand_dims(img_array, axis=0)
+    preprocessed_img = preprocess_input(expanded_img_array)
+
+    # Extract features using the model and normalize the result
+
+    result = model.predict(preprocessed_img).flatten()
+    normalized_result = result / norm(result)
+
+    return normalized_result
+
+# List all filenames in the 'images' directory
+
+filenames = []
+
+for file in os.listdir('images'):
+    filenames.append(os.path.join('images',file))
+
+feature_list = []   # List to store extracted features
+
+# Loop through each image file, extract features, and append to the feature_list
+
+for file in tqdm(filenames):
+    feature_list.append(extract_features(file,model))
+# Save the extracted features and filenames to pickle files
+pickle.dump(feature_list,open('embeddings.pkl','wb'))   # Save features
+pickle.dump(filenames,open('filenames.pkl','wb'))       # save filenames

chatbot.py

@@ -0,0 +1,123 @@
+import os
+import pickle
+import torch
+import pickle
+import matplotlib.pyplot as plt
+from langchain_community.document_loaders import TextLoader
+from datasets import load_dataset
+from sentence_transformers import SentenceTransformer, util
+from transformers import GPT2LMHeadModel, GPT2Tokenizer
+from transformers import BertModel, BertTokenizer
+from langchain_core.prompts import PromptTemplate
+
+os.environ['HUGGINGFACEHUB_API_TOKEN'] = "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"
+
+class Chatbot:
+    def __init__(self):
+        self.load_data()
+        self.load_models()
+        self.load_embeddings()
+        self.load_template()
+
+    def load_data(self):
+        self.data = load_dataset("ashraq/fashion-product-images-small", split="train")
+        self.images = self.data["image"]
+        self.product_frame = self.data.remove_columns("image").to_pandas()
+        self.product_data = self.product_frame.reset_index(drop=True).to_dict(orient='index')
+
+    def load_template(self):
+        self.template = """
+        You are a fashion shopping assistant that wants to convert customers based on the information given.
+        Describe season and usage given in the context in your interaction with the customer.
+        Use a bullet list when describing each product.
+        If user ask general question then answer them accordingly, the question may be like when the store will open, where is your store located.
+        Context: {context}
+        User question: {question}
+        Your response: {response}
+        """
+        self.prompt = PromptTemplate.from_template(self.template)
+
+    def load_models(self):
+        self.model = SentenceTransformer('clip-ViT-B-32')
+        self.bert_model_name = "bert-base-uncased"
+        self.bert_model = BertModel.from_pretrained(self.bert_model_name)
+        self.bert_tokenizer = BertTokenizer.from_pretrained(self.bert_model_name)
+        self.gpt2_model_name = "gpt2"
+        self.gpt2_model = GPT2LMHeadModel.from_pretrained(self.gpt2_model_name)
+        self.gpt2_tokenizer = GPT2Tokenizer.from_pretrained(self.gpt2_model_name)
+
+    def load_embeddings(self):
+        if os.path.exists("embeddings_cache.pkl"):
+            with open("embeddings_cache.pkl", "rb") as f:
+                embeddings_cache = pickle.load(f)
+            self.image_embeddings = embeddings_cache["image_embeddings"]
+            self.text_embeddings = embeddings_cache["text_embeddings"]
+        else:
+            self.image_embeddings = self.model.encode([image for image in self.images])
+            self.text_embeddings = self.model.encode(self.product_frame['productDisplayName'])
+            embeddings_cache = {"image_embeddings": self.image_embeddings, "text_embeddings": self.text_embeddings}
+            with open("embeddings_cache.pkl", "wb") as f:
+                pickle.dump(embeddings_cache, f)
+
+    def create_docs(self, results):
+        docs = []
+        for result in results:
+            pid = result['corpus_id']
+            score = result['score']
+            result_string = ''
+            result_string += "Product Name:" + self.product_data[pid]['productDisplayName'] + \
+                             ';' + "Category:" + self.product_data[pid]['masterCategory'] + \
+                             ';' + "Article Type:" + self.product_data[pid]['articleType'] + \
+                             ';' + "Usage:" + self.product_data[pid]['usage'] + \
+                             ';' + "Season:" + self.product_data[pid]['season'] + \
+                             ';' + "Gender:" + self.product_data[pid]['gender']
+            # Assuming text is imported from somewhere else
+            doc = text(page_content=result_string)
+            doc.metadata['pid'] = str(pid)
+            doc.metadata['score'] = score
+            docs.append(doc)
+        return docs
+
+    def get_results(self, query, embeddings, top_k=10):
+        query_embedding = self.model.encode([query])
+        cos_scores = util.pytorch_cos_sim(query_embedding, embeddings)[0]
+        top_results = torch.topk(cos_scores, k=top_k)
+        indices = top_results.indices.tolist()
+        scores = top_results.values.tolist()
+        results = [{'corpus_id': idx, 'score': score} for idx, score in zip(indices, scores)]
+        return results
+
+    def display_text_and_images(self, results_text):
+        for result in results_text:
+            pid = result['corpus_id']
+            product_info = self.product_data[pid]
+            print("Product Name:", product_info['productDisplayName'])
+            print("Category:", product_info['masterCategory'])
+            print("Article Type:", product_info['articleType'])
+            print("Usage:", product_info['usage'])
+            print("Season:", product_info['season'])
+            print("Gender:", product_info['gender'])
+            print("Score:", result['score'])
+            plt.imshow(self.images[pid])
+            plt.axis('off')
+            plt.show()
+
+    @staticmethod
+    def cos_sim(a, b):
+        a_norm = torch.nn.functional.normalize(a, p=2, dim=1)
+        b_norm = torch.nn.functional.normalize(b, p=2, dim=1)
+        return torch.mm(a_norm.T, b_norm)  # Reshape a_norm to (768, 1)
+
+    def generate_response(self, query):
+        # Process the user query and generate a response
+        results_text = self.get_results(query, self.text_embeddings)
+
+        # Generate chatbot response
+        chatbot_response = "This is a placeholder response from the chatbot."  # Placeholder, replace with actual response
+
+        # Display recommended products
+        self.display_text_and_images(results_text)
+
+        # Return both chatbot response and recommended products
+        return chatbot_response,results_text
+

embeddings.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:88399617409c087450736ddfa9c64f99365cce80055cdcd2075f8dac76fe2a3e
+size 134

embeddings_cache.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f3c0e69a8744b7f05c185f17a4d546e41e94982c2d72b9bee915fe174a2ecd1
+size 134

filenames.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d0dfe2467c266620c47ca39138c3d4ad1c3d68e365ab007f44cba5d083b9fde
+size 131

main.py

@@ -0,0 +1,80 @@
+import streamlit as st
+import altair as alt
+import os
+from PIL import Image
+import numpy as np
+import pickle
+import tensorflow
+from tensorflow.keras.preprocessing import image
+from tensorflow.keras.layers import GlobalMaxPooling2D
+from tensorflow.keras.applications.resnet50 import ResNet50,preprocess_input
+from sklearn.neighbors import NearestNeighbors
+from numpy.linalg import norm
+
+feature_list = np.array(pickle.load(open('embeddings.pkl','rb')))
+filenames = pickle.load(open('filenames.pkl','rb'))
+
+model = ResNet50(weights='imagenet',include_top=False,input_shape=(224,224,3))
+model.trainable = False
+
+model = tensorflow.keras.Sequential([
+    model,
+    GlobalMaxPooling2D()
+])
+
+st.title('Fashion Recommender System')
+
+def save_uploaded_file(uploaded_file):
+    try:
+        with open(os.path.join('uploads',uploaded_file.name),'wb') as f:
+            f.write(uploaded_file.getbuffer())
+        return 1
+    except:
+        return 0
+
+def feature_extraction(img_path,model):
+    img = image.load_img(img_path, target_size=(224, 224))
+    img_array = image.img_to_array(img)
+    expanded_img_array = np.expand_dims(img_array, axis=0)
+    preprocessed_img = preprocess_input(expanded_img_array)
+    result = model.predict(preprocessed_img).flatten()
+    normalized_result = result / norm(result)
+
+    return normalized_result
+
+def recommend(features,feature_list):
+    neighbors = NearestNeighbors(n_neighbors=6, algorithm='brute', metric='euclidean')
+    neighbors.fit(feature_list)
+
+    distances, indices = neighbors.kneighbors([features])
+
+    return indices
+
+# steps
+# file upload -> save
+uploaded_file = st.file_uploader("Choose an image")
+if uploaded_file is not None:
+    if save_uploaded_file(uploaded_file):
+        # display the file
+        display_image = Image.open(uploaded_file)
+        st.image(display_image)
+        # feature extract
+        features = feature_extraction(os.path.join("uploads",uploaded_file.name),model)
+        #st.text(features)
+        # recommendention
+        indices = recommend(features,feature_list)
+        # show
+        col1,col2,col3,col4,col5 = st.beta_columns(5)
+
+        with col1:
+            st.image(filenames[indices[0][0]])
+        with col2:
+            st.image(filenames[indices[0][1]])
+        with col3:
+            st.image(filenames[indices[0][2]])
+        with col4:
+            st.image(filenames[indices[0][3]])
+        with col5:
+            st.image(filenames[indices[0][4]])
+    else:
+        st.header("Some error occured in file upload")

main_1.py

@@ -0,0 +1,228 @@
+import streamlit as st
+import mysql.connector
+import os
+from PIL import Image
+import numpy as np
+import pickle
+import tensorflow
+from tensorflow.keras.preprocessing import image
+from tensorflow.keras.layers import GlobalMaxPooling2D
+from tensorflow.keras.applications.resnet50 import ResNet50, preprocess_input
+from sklearn.neighbors import NearestNeighbors
+from numpy.linalg import norm
+from chatbot import Chatbot  # Assuming you have a chatbot module
+
+# Function to authenticate user credentials from the database
+def authenticate_user(username, password):
+    try:
+        # Connect to the MySQL database
+        connection = mysql.connector.connect(
+            host="sql6.freemysqlhosting.net",
+            database="sql6697353",
+            user="sql6697353",
+            password="wvfSQJbmMs"
+        )
+
+        # Create a cursor object to execute SQL queries
+        cursor = connection.cursor()
+
+        # Query to check if the username and password match
+        query = "SELECT * FROM users WHERE username = %s AND password = %s"
+        cursor.execute(query, (username, password))
+        user = cursor.fetchone()  # Fetch the first row
+
+        # If user exists, return True (authentication successful)
+        if user:
+            return True
+        else:
+            return False
+
+    except mysql.connector.Error as error:
+        st.error(f"Error: {error}")
+        return False
+
+    finally:
+        # Close the cursor and database connection
+        if 'connection' in locals() and connection.is_connected():
+            cursor.close()
+            connection.close()
+
+# Define your login function
+def login():
+    st.header("Login Page")
+    # Add your login code here
+    username = st.text_input("Username")
+    password = st.text_input("Password", type="password")
+    if st.button("Login"):
+        # Authenticate user with provided credentials
+        if authenticate_user(username, password):
+            st.session_state.logged_in = True
+            query_params = st.experimental_get_query_params()
+            query_params["page"] = ["Dashboard"]
+            st.experimental_set_query_params(**query_params)
+            # Redirect to dashboard
+            st.success("Login successful!")
+        else:
+            st.error("Invalid username or password")
+
+# Define your registration function
+def register():
+    st.header("Registration Page")
+    # Add your registration code here
+    username = st.text_input("Username")
+    password = st.text_input("Password", type="password")
+    email = st.text_input("Email")
+
+    if st.button("Register"):
+        # Validate input
+        if not username or not password or not email:
+            st.error("Please enter username, password, and email.")
+        else:
+            try:
+                # Connect to the MySQL database
+                connection = mysql.connector.connect(
+                    host="sql6.freemysqlhosting.net",
+                    database="sql6697353",
+                    user="sql6697353",
+                    password="wvfSQJbmMs"
+                )
+
+                # Create a cursor object to execute SQL queries
+                cursor = connection.cursor()
+
+                # Check if username or email already exists
+                cursor.execute("SELECT * FROM users WHERE username = %s OR email = %s", (username, email))
+                result = cursor.fetchone()
+                if result:
+                    st.error("Username or email already exists. Please choose different ones.")
+                else:
+                    # Insert new user into database
+                    cursor.execute("INSERT INTO users (username, password, email) VALUES (%s, %s, %s)", (username, password, email))
+                    connection.commit()
+                    st.success("Registration successful. You can now log in.")
+            except mysql.connector.Error as error:
+                st.error(f"Error: {error}")
+            finally:
+                # Close the cursor and database connection
+                if 'connection' in locals() and connection.is_connected():
+                    cursor.close()
+                    connection.close()
+
+
+# Define function for feature extraction
+def feature_extraction(img_path, model):
+    img = image.load_img(img_path, target_size=(224, 224))
+    img_array = image.img_to_array(img)
+    expanded_img_array = np.expand_dims(img_array, axis=0)
+    preprocessed_img = preprocess_input(expanded_img_array)
+    result = model.predict(preprocessed_img).flatten()
+    normalized_result = result / norm(result)
+    return normalized_result
+
+# Define function for recommendation
+def recommend(features, feature_list):
+    neighbors = NearestNeighbors(n_neighbors=6, algorithm='brute', metric='euclidean')
+    neighbors.fit(feature_list)
+    distances, indices = neighbors.kneighbors([features])
+    return indices
+
+# Function to save uploaded file
+def save_uploaded_file(uploaded_file):
+    try:
+        with open(os.path.join('uploads', uploaded_file.name), 'wb') as f:
+            f.write(uploaded_file.getbuffer())
+        return True
+    except:
+        return False
+
+# Function to show dashboard content
+def show_dashboard():
+    st.header("Fashion Recommender System")
+    chatbot = Chatbot()
+    # Load ResNet model for image feature extraction
+    model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
+    model.trainable = False
+    model = tensorflow.keras.Sequential([
+        model,
+        GlobalMaxPooling2D()
+    ])
+
+    feature_list = np.array(pickle.load(open('embeddings.pkl', 'rb')))
+    filenames = pickle.load(open('filenames.pkl', 'rb'))
+
+    # File upload section
+    uploaded_file = st.file_uploader("Choose an image")
+    if uploaded_file is not None:
+        if save_uploaded_file(uploaded_file):
+            # Display the uploaded image
+            display_image = Image.open(uploaded_file)
+            st.image(display_image)
+
+            # Feature extraction
+            features = feature_extraction(os.path.join("uploads", uploaded_file.name), model)
+
+            # Recommendation
+            indices = recommend(features, feature_list)
+
+            # Display recommended products
+            col1, col2, col3, col4, col5 = st.beta_columns(5)
+            with col1:
+                st.image(filenames[indices[0][0]])
+            with col2:
+                st.image(filenames[indices[0][1]])
+            with col3:
+                st.image(filenames[indices[0][2]])
+            with col4:
+                st.image(filenames[indices[0][3]])
+            with col5:
+                st.image(filenames[indices[0][4]])
+
+        else:
+            st.header("Some error occurred in file upload")
+
+    # Chatbot section
+    user_question = st.text_input("Ask a question:")
+    if user_question:
+        bot_response, recommended_products = chatbot.generate_response(user_question)
+        st.write("Chatbot:", bot_response)
+
+        # Display recommended products
+        for result in recommended_products:
+            pid = result['corpus_id']
+            product_info = chatbot.product_data[pid]
+            st.write("Product Name:", product_info['productDisplayName'])
+            st.write("Category:", product_info['masterCategory'])
+            st.write("Article Type:", product_info['articleType'])
+            st.write("Usage:", product_info['usage'])
+            st.write("Season:", product_info['season'])
+            st.write("Gender:", product_info['gender'])
+            st.image(chatbot.images[pid])
+
+# Main Streamlit app
+def main():
+    # Give title to the app
+    st.title("Fashion Recommender System")
+
+    # Sidebar navigation
+    page = st.sidebar.radio("Navigation", ["Login", "Register", "Dashboard"])
+
+    # Check if user is logged in
+    if "logged_in" not in st.session_state:
+        st.session_state.logged_in = False
+
+    # Show login page if user is not logged in
+    if not st.session_state.logged_in:
+        if page == "Login":
+            login()
+
+    # Show registration page if selected in the sidebar
+    if page == "Register":
+        register()
+
+    # Show dashboard if selected in the sidebar and user is logged in
+    if page == "Dashboard" and st.session_state.logged_in:
+        show_dashboard()
+
+# Run the main app
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,13 @@
+streamlit
+torch
+matplotlib
+langchain-core  # Might need adjustment based on availability
+datasets
+sentence-transformers
+transformers
+
+# Additional libraries based on your code (if applicable)
+mysql-connector-python  # If using MySQL database
+Pillow  # If using PIL for image processing
+scikit-learn  # If using scikit-learn (used for sklearn in your code)
+langchain_community

test.py

@@ -0,0 +1,48 @@
+import pickle
+import tensorflow
+import numpy as np
+from numpy.linalg import norm
+from tensorflow.keras.preprocessing import image
+from tensorflow.keras.layers import GlobalMaxPooling2D
+from tensorflow.keras.applications.resnet50 import ResNet50, preprocess_input
+from sklearn.neighbors import NearestNeighbors
+import cv2
+
+# Load the precomputed feature vectors and filenames from pickle files
+feature_list = np.array(pickle.load(open('embeddings.pkl', 'rb')))
+filenames = pickle.load(open('filenames.pkl', 'rb'))
+
+# Load ResNet50 model without the top layer for feature extraction
+model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
+model.trainable = False
+
+# Create a Sequential model with ResNet50 and GlobalMaxPooling2D layers
+model = tensorflow.keras.Sequential([
+    model,
+    GlobalMaxPooling2D()
+])
+
+# Load and preprocess the query image
+img = image.load_img('sample/khade.jpg', target_size=(224, 224))
+img_array = image.img_to_array(img)
+expanded_img_array = np.expand_dims(img_array, axis=0)
+preprocessed_img = preprocess_input(expanded_img_array)
+
+# Extract features from the query image and normalize
+result = model.predict(preprocessed_img).flatten()
+normalized_result = result / norm(result)
+
+# Initialize NearestNeighbors model and fit with the feature vectors
+neighbors = NearestNeighbors(n_neighbors=6, algorithm='brute', metric='euclidean')
+neighbors.fit(feature_list)
+
+# Find the nearest neighbors (excluding itself)
+distances, indices = neighbors.kneighbors([normalized_result])
+
+print(indices)  # Print the indices of nearest neighbors
+
+# Display the nearest neighbor images
+for file in indices[0][0:5]:
+    temp_img = cv2.imread(filenames[file])
+    cv2.imshow('output', cv2.resize(temp_img, (312, 312)))
+    cv2.waitKey(0)