Initial commit with full project

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/Recommender System.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="jdk" jdkName="Python 3.12 (Recommender System)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.12 (Recommender System)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.12 (Recommender System)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/Recommender System.iml" filepath="$PROJECT_DIR$/.idea/Recommender System.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

app.py

@@ -0,0 +1,69 @@
+import streamlit as st
+from PIL import Image
+from io import BytesIO
+from unique_product_mapping import product_to_category, goal_format, unique_items_list
+from cooccurance import get_recommendations, co_occurrence_df
+from jaccard_similarity import collaborative_recommendations, product_item_matrix
+
+# Helper function to load images
+def load_image(image_path):
+    try:
+        with open(image_path, "rb") as f:
+            img = Image.open(BytesIO(f.read()))
+        return img
+    except Exception as e:
+        st.error(f"Error loading image: {e}")
+        return None
+
+# Function to get items bought together
+def get_items_bought_together(product_name):
+    cosine_recommendations = get_recommendations(product_name, co_occurrence_df, product_item_matrix)
+    jacquard_recommendations = collaborative_recommendations(product_name)
+    common_recommendations = set(cosine_recommendations) | set(jacquard_recommendations)
+    return list(common_recommendations)
+
+# Streamlit UI
+def main():
+    st.title("Groceries Recommender")
+
+    # Product list for selection
+    product_list = unique_items_list
+
+    # Select a product
+    selected_product = st.selectbox("Type or select a product", options=product_list)
+    search_button = st.button("Commence Search")
+
+    if search_button:
+        if selected_product:
+            # Display the basic search results
+            st.write("Basic Search Results:")
+            st.image(load_image(product_to_category[selected_product]['image']), caption=selected_product.capitalize())
+
+            product_info = product_to_category[selected_product]
+
+            # Display items bought together
+            st.write("Items Bought Together:")
+            items_bought_together = get_items_bought_together(selected_product)
+            if items_bought_together:
+                for i in range(0, len(items_bought_together), 4):
+                    cols = st.columns(min(4, len(items_bought_together) - i))
+                    for j, item in enumerate(items_bought_together[i:i + 4]):
+                        cols[j].image(load_image(product_to_category[item]['image']), caption=item.capitalize())
+            else:
+                st.write("No items bought together recommendations found.")
+
+            # Display category-based recommendations
+            st.write(f"Products From {product_info['category'].capitalize()} Category:")
+            category_items = goal_format.get(product_info['category'], [])
+            if category_items:
+                for i in range(0, len(category_items), 4):
+                    cols = st.columns(min(4, len(category_items) - i))
+                    for j, item in enumerate(category_items[i:i + 4]):
+                        cols[j].image(load_image(product_to_category[item]['image']), caption=item.capitalize())
+            else:
+                st.write(f"No other products found in {product_info['category']} category.")
+        else:
+            st.write("No product selected.")
+
+if __name__ == "__main__":
+    main()

basic_search.py

@@ -0,0 +1,11 @@
+from load_data import items
+
+
+# Simple search function
+def search_products(query, items):
+    results = []
+    for transaction in items:
+        for item in transaction:
+            if query.lower() in item.lower():
+                results.append(item)
+    return list(set(results))

category_based.py

@@ -0,0 +1,40 @@
+from unique_product_mapping import product_to_category, goal_format
+
+
+def get_recommendations(selected_item, goal_format):
+    # Find the class/category of the selected item
+    selected_class_dict = product_to_category.get(selected_item, None)
+
+    if selected_class_dict is None:
+        print("Product not found.")
+        return None, []
+
+    selected_class = selected_class_dict.get('category', None)
+    if not selected_class:
+        print("Category not found for the selected product.")
+        return None, []
+
+    print(f"Selected Category: {selected_class}")
+
+    # Filter all products in the same class/category
+    same_class_products = goal_format.get(selected_class, [])
+
+    # Remove the selected item itself from the list of recommendations (optional)
+    if selected_item in same_class_products:
+        same_class_products.remove(selected_item)
+
+    # Prepare a list of recommendations with their image paths
+    recommendations_with_images = [
+        {"product": product, "image": product_to_category.get(product, {}).get('image', 'No image available')}
+        for product in same_class_products
+    ]
+
+    return selected_class, recommendations_with_images
+
+
+def cat_recc(selected_item):
+    category, recommendations = get_recommendations(selected_item, goal_format)
+    print(f"Selected Item: {selected_item}")
+    print("Recommended:")
+    for recommendation in recommendations:
+        print(f"Product: {recommendation['product']}, Image Path: {recommendation['image']}")

combi_system.py

@@ -0,0 +1,15 @@
+from cooccurance import get_recommendations, co_occurrence_df
+from jaccard_similarity import collaborative_recommendations, product_item_matrix
+
+
+def combi_system(product):
+    # Test Cosine Similarity Based Recommendations with Confidence
+    cosine_recommendations = get_recommendations(product, co_occurrence_df, product_item_matrix)
+
+    # Test Item-Based Collaborative Filtering with Jacquard Similarity
+    jacquard_recommendations = collaborative_recommendations(product)
+
+    # Combine recommendations
+    common_recommendations = set(cosine_recommendations) | set(jacquard_recommendations)
+
+    return list(common_recommendations)  # Return the combined recommendations

cooccurance.py

@@ -0,0 +1,43 @@
+import pandas as pd
+from itertools import combinations
+from collections import defaultdict
+from load_data import items
+
+# Flatten the items into a single list for vectorization
+flat_items = [item for sublist in items for item in sublist]
+
+# Create a co-occurrence matrix
+product_co_occurrence = defaultdict(int)
+for sublist in items:
+    for combination in combinations(sublist, 2):
+        product_co_occurrence[tuple(sorted(combination))] += 1
+
+# Convert to DataFrame
+co_occurrence_df = pd.DataFrame(list(product_co_occurrence.items()), columns=["Pair", "Frequency"])
+
+# Sort to find the most common co-occurring products
+co_occurrence_df = co_occurrence_df.sort_values(by="Frequency", ascending=False)
+
+
+# Function to calculate confidence
+def calculate_confidence(item1, item2, df):
+    item1_transactions = df[df[item1] > 0].shape[0]
+    both_transactions = df[(df[item1] > 0) & (df[item2] > 0)].shape[0]
+    return both_transactions / item1_transactions
+
+
+# Function to get recommendations based on a product
+def get_recommendations(product_name, co_occurrence_df, df, confidence_threshold=0.1):
+    # Find pairs that include the product name
+    relevant_pairs = co_occurrence_df[co_occurrence_df["Pair"].apply(lambda x: product_name in x)]
+
+    # Extract the other product in the pair and calculate confidence
+    recommended_products = []
+    for pair in relevant_pairs["Pair"]:
+        other_product = pair[0] if pair[1] == product_name else pair[1]
+        confidence = calculate_confidence(product_name, other_product, df)
+        if confidence > confidence_threshold:
+            recommended_products.append(other_product)
+
+    # Return the top recommendations
+    return recommended_products[:3]