API

Recommendation_System_in_Python.ipynb

@@ -0,0 +1,392 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "SKRYfHwWyVaG"
+      },
+      "outputs": [],
+      "source": [
+        "# Importing Libraries\n",
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import sklearn\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "import warnings\n",
+        "warnings.simplefilter(action='ignore', category=FutureWarning)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#loading rating dataset\n",
+        "ratings = pd.read_csv(\"https://s3-us-west-2.amazonaws.com/recommender-tutorial/ratings.csv\")\n",
+        "print(ratings.head())"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "v_ZFn93Wy1ho",
+        "outputId": "97f98476-d909-4050-bc37-68369391d756"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "   userId  movieId  rating  timestamp\n",
+            "0       1        1     4.0  964982703\n",
+            "1       1        3     4.0  964981247\n",
+            "2       1        6     4.0  964982224\n",
+            "3       1       47     5.0  964983815\n",
+            "4       1       50     5.0  964982931\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# loading movie dataset\n",
+        "movies = pd.read_csv(\"https://s3-us-west-2.amazonaws.com/recommender-tutorial/movies.csv\")\n",
+        "print(movies.head())"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "_RCPOQWfy269",
+        "outputId": "4c3c68a1-dbbb-4795-d96a-4f9c11d3731b"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "   movieId                               title  \\\n",
+            "0        1                    Toy Story (1995)   \n",
+            "1        2                      Jumanji (1995)   \n",
+            "2        3             Grumpier Old Men (1995)   \n",
+            "3        4            Waiting to Exhale (1995)   \n",
+            "4        5  Father of the Bride Part II (1995)   \n",
+            "\n",
+            "                                        genres  \n",
+            "0  Adventure|Animation|Children|Comedy|Fantasy  \n",
+            "1                   Adventure|Children|Fantasy  \n",
+            "2                               Comedy|Romance  \n",
+            "3                         Comedy|Drama|Romance  \n",
+            "4                                       Comedy  \n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "n_ratings = len(ratings)\n",
+        "n_movies = len(ratings['movieId'].unique())\n",
+        "n_users = len(ratings['userId'].unique())\n",
+        "\n",
+        "print(f\"Number of ratings: {n_ratings}\")\n",
+        "print(f\"Number of unique movieId's: {n_movies}\")\n",
+        "print(f\"Number of unique users: {n_users}\")\n",
+        "print(f\"Average ratings per user: {round(n_ratings/n_users, 2)}\")\n",
+        "print(f\"Average ratings per movie: {round(n_ratings/n_movies, 2)}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ypivRYgqy4kb",
+        "outputId": "360eef9e-9186-4ed6-ed50-fe8e6a3fabf0"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Number of ratings: 100836\n",
+            "Number of unique movieId's: 9724\n",
+            "Number of unique users: 610\n",
+            "Average ratings per user: 165.3\n",
+            "Average ratings per movie: 10.37\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "user_freq = ratings[['userId', 'movieId']].groupby(\n",
+        "    'userId').count().reset_index()\n",
+        "user_freq.columns = ['userId', 'n_ratings']\n",
+        "print(user_freq.head())"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "PYZsye4-zAfi",
+        "outputId": "fb38061d-d9bc-4552-de9b-de418780ec32"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "   userId  n_ratings\n",
+            "0       1        232\n",
+            "1       2         29\n",
+            "2       3         39\n",
+            "3       4        216\n",
+            "4       5         44\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Find Lowest and Highest rated movies:\n",
+        "mean_rating = ratings.groupby('movieId')[['rating']].mean()\n",
+        "# Lowest rated movies\n",
+        "lowest_rated = mean_rating['rating'].idxmin()\n",
+        "movies.loc[movies['movieId'] == lowest_rated]\n",
+        "# Highest rated movies\n",
+        "highest_rated = mean_rating['rating'].idxmax()\n",
+        "movies.loc[movies['movieId'] == highest_rated]\n",
+        "# show number of people who rated movies rated movie highest\n",
+        "ratings[ratings['movieId']==highest_rated]\n",
+        "# show number of people who rated movies rated movie lowest\n",
+        "ratings[ratings['movieId']==lowest_rated]\n",
+        "\n",
+        "## the above movies has very low dataset. We will use bayesian average\n",
+        "movie_stats = ratings.groupby('movieId')[['rating']].agg(['count', 'mean'])\n",
+        "movie_stats.columns = movie_stats.columns.droplevel()"
+      ],
+      "metadata": {
+        "id": "H1s9d6QIzBzv"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Now, we create user-item matrix using scipy csr matrix\n",
+        "from scipy.sparse import csr_matrix\n",
+        "\n",
+        "def create_matrix(df):\n",
+        "\n",
+        "    N = len(df['userId'].unique())\n",
+        "    M = len(df['movieId'].unique())\n",
+        "\n",
+        "    # Map Ids to indices\n",
+        "    user_mapper = dict(zip(np.unique(df[\"userId\"]), list(range(N))))\n",
+        "    movie_mapper = dict(zip(np.unique(df[\"movieId\"]), list(range(M))))\n",
+        "\n",
+        "    # Map indices to IDs\n",
+        "    user_inv_mapper = dict(zip(list(range(N)), np.unique(df[\"userId\"])))\n",
+        "    movie_inv_mapper = dict(zip(list(range(M)), np.unique(df[\"movieId\"])))\n",
+        "\n",
+        "    user_index = [user_mapper[i] for i in df['userId']]\n",
+        "    movie_index = [movie_mapper[i] for i in df['movieId']]\n",
+        "\n",
+        "    X = csr_matrix((df[\"rating\"], (movie_index, user_index)), shape=(M, N))\n",
+        "\n",
+        "    return X, user_mapper, movie_mapper, user_inv_mapper, movie_inv_mapper\n",
+        "\n",
+        "X, user_mapper, movie_mapper, user_inv_mapper, movie_inv_mapper = create_matrix(ratings)"
+      ],
+      "metadata": {
+        "id": "2tG23gzjzDLg"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "\"\"\"\n",
+        "Find similar movies using KNN\n",
+        "\"\"\"\n",
+        "from sklearn.neighbors import NearestNeighbors\n",
+        "def find_similar_movies(movie_id, X, k, metric='cosine', show_distance=False):\n",
+        "\n",
+        "    neighbour_ids = []\n",
+        "\n",
+        "    movie_ind = movie_mapper[movie_id]\n",
+        "    movie_vec = X[movie_ind]\n",
+        "    k+=1\n",
+        "    kNN = NearestNeighbors(n_neighbors=k, algorithm=\"brute\", metric=metric)\n",
+        "    kNN.fit(X)\n",
+        "    movie_vec = movie_vec.reshape(1,-1)\n",
+        "    neighbour = kNN.kneighbors(movie_vec, return_distance=show_distance)\n",
+        "    for i in range(0,k):\n",
+        "        n = neighbour.item(i)\n",
+        "        neighbour_ids.append(movie_inv_mapper[n])\n",
+        "    neighbour_ids.pop(0)\n",
+        "    return neighbour_ids\n",
+        "\n",
+        "\n",
+        "movie_titles = dict(zip(movies['movieId'], movies['title']))\n",
+        "\n",
+        "movie_id = 3\n",
+        "\n",
+        "similar_ids = find_similar_movies(movie_id, X, k=10)\n",
+        "movie_title = movie_titles[movie_id]\n",
+        "\n",
+        "print(f\"Since you watched {movie_title}\")\n",
+        "for i in similar_ids:\n",
+        "    print(movie_titles[i])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "onBGmGk5zGAZ",
+        "outputId": "c5a409ff-c16d-413f-9339-a2ff977eef69"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Since you watched Grumpier Old Men (1995)\n",
+            "Grumpy Old Men (1993)\n",
+            "Striptease (1996)\n",
+            "Nutty Professor, The (1996)\n",
+            "Twister (1996)\n",
+            "Father of the Bride Part II (1995)\n",
+            "Broken Arrow (1996)\n",
+            "Bio-Dome (1996)\n",
+            "Truth About Cats & Dogs, The (1996)\n",
+            "Sabrina (1995)\n",
+            "Birdcage, The (1996)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def recommend_movies_for_user(user_id, X, user_mapper, movie_mapper, movie_inv_mapper, k=10):\n",
+        "    df1 = ratings[ratings['userId'] == user_id]\n",
+        "\n",
+        "    if df1.empty:\n",
+        "        print(f\"User with ID {user_id} does not exist.\")\n",
+        "        return\n",
+        "\n",
+        "    movie_id = df1[df1['rating'] == max(df1['rating'])]['movieId'].iloc[0]\n",
+        "\n",
+        "    movie_titles = dict(zip(movies['movieId'], movies['title']))\n",
+        "\n",
+        "    similar_ids = find_similar_movies(movie_id, X, k)\n",
+        "    movie_title = movie_titles.get(movie_id, \"Movie not found\")\n",
+        "\n",
+        "    if movie_title == \"Movie not found\":\n",
+        "        print(f\"Movie with ID {movie_id} not found.\")\n",
+        "        return\n",
+        "\n",
+        "    print(f\"Since you watched {movie_title}, you might also like:\")\n",
+        "    for i in similar_ids:\n",
+        "        print(movie_titles.get(i, \"Movie not found\"))"
+      ],
+      "metadata": {
+        "id": "PrN_SjhMzHxy"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "user_id = 150  # Replace with the desired user ID\n",
+        "recommend_movies_for_user(user_id, X, user_mapper, movie_mapper, movie_inv_mapper, k=10)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "L13wNuTOzJry",
+        "outputId": "5316c18d-8323-4fc8-8ed0-a503edf93f29"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Since you watched Twelve Monkeys (a.k.a. 12 Monkeys) (1995), you might also like:\n",
+            "Pulp Fiction (1994)\n",
+            "Terminator 2: Judgment Day (1991)\n",
+            "Independence Day (a.k.a. ID4) (1996)\n",
+            "Seven (a.k.a. Se7en) (1995)\n",
+            "Fargo (1996)\n",
+            "Fugitive, The (1993)\n",
+            "Usual Suspects, The (1995)\n",
+            "Jurassic Park (1993)\n",
+            "Star Wars: Episode IV - A New Hope (1977)\n",
+            "Heat (1995)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "user_id = 415  # Replace with the desired user ID\n",
+        "recommend_movies_for_user(user_id, X, user_mapper, movie_mapper, movie_inv_mapper, k=10)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "pEZ5ISP8zLB1",
+        "outputId": "e61b8c3f-db5d-4c49-b876-5bc19a490ce4"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Since you watched Pulp Fiction (1994), you might also like:\n",
+            "Silence of the Lambs, The (1991)\n",
+            "Shawshank Redemption, The (1994)\n",
+            "Seven (a.k.a. Se7en) (1995)\n",
+            "Forrest Gump (1994)\n",
+            "Usual Suspects, The (1995)\n",
+            "Braveheart (1995)\n",
+            "Fight Club (1999)\n",
+            "Fargo (1996)\n",
+            "Terminator 2: Judgment Day (1991)\n",
+            "Reservoir Dogs (1992)\n"
+          ]
+        }
+      ]
+    }
+  ]
+}

app.py

@@ -1,8 +1,16 @@
 #Fast APi Packages
-from fastapi import FastAPI,File
+from fastapi import FastAPI,File, HTTPException
 from pydantic import BaseModel
 import json
 
+
+from typing import List, Dict, Any
+import pandas as pd
+import numpy as np
+from sklearn.metrics.pairwise import cosine_similarity
+from scipy import sparse
+from datetime import datetime
+
 #SkillExtraction Packages
 import psycopg2
 import pandas as pd
@@ -39,6 +47,15 @@ nlp = spacy.load("en_core_web_lg")
 skill_extractor = SkillExtractor(nlp, SKILL_DB, PhraseMatcher)
 model = SentenceTransformer('all-MiniLM-L6-v2')
 
+purchase_history = pd.read_excel('datasetsample.xlsx', sheet_name='Transaction History', 
+                               parse_dates=['Purchase_Date'])
+purchase_history['Customer_Id'] = purchase_history['Customer_Id'].astype(str)
+product_categories = purchase_history[['Product_Id', 'Category']].drop_duplicates().set_index('Product_Id')['Category'].to_dict()
+purchase_counts = purchase_history.groupby(['Customer_Id', 'Product_Id']).size().unstack(fill_value=0)
+sparse_purchase_counts = sparse.csr_matrix(purchase_counts)
+cosine_similarities = cosine_similarity(sparse_purchase_counts.T)
+
+
 @app.get("/")
 async def root():
  return {"Recommendation":"Recommendation Version 1.00, https://vaibhav84-recommendation.hf.space/redoc , https://vaibhav84-recommendation.hf.space/docs"}
@@ -58,6 +75,31 @@ def UploadJobDescription(CustomerID : str, CustomerPwd: str):
     except Exception as e:
         return "An error occurred: {e}" 
 
+@app.get("/recommendations/{customer_id}")
+async def get_recommendations(customer_id: str, n: int = 5):
+    """
+    Get recommendations for a customer
+    
+    Parameters:
+    - customer_id: The ID of the customer
+    - n: Number of recommendations to return (default: 5)
+    
+    Returns:
+    - JSON object containing purchase history and recommendations
+    """
+    try:
+        purchased_items, recommended_items = get_customer_items_and_recommendations(customer_id, n)
+        
+        return {
+            "customer_id": customer_id,
+            "purchase_history": purchased_items,
+            "recommendations": recommended_items
+        }
+    except Exception as e:
+        raise HTTPException(status_code=404, detail=f"Error processing customer ID: {customer_id}. {str(e)}")
+
+
+
 @app.post("/UploadJobDescription/")
 async def UploadJobDescription(file: bytes =  File(...), FileName: str = "sample.pdf"):
     try:   
@@ -87,6 +129,51 @@ def UpdateSkills(Skills : ClassModals.Modals.UpdateSkillDetails):
 def AllSkills():
     return (AddSkill.GetSkillDetails())
 
+
+def get_customer_items_and_recommendations(user_id: str, n: int = 5) -> tuple[List[Dict], List[Dict]]:
+    """
+    Get both purchased items and recommendations for a user
+    """
+    user_id = str(user_id)
+    
+    if user_id not in purchase_counts.index:
+        return [], []
+    
+    purchased_items = list(purchase_counts.columns[purchase_counts.loc[user_id] > 0])
+    
+    purchased_items_info = []
+    user_purchases = purchase_history[purchase_history['Customer_Id'] == user_id]
+    
+    for item in purchased_items:
+        item_purchases = user_purchases[user_purchases['Product_Id'] == item]
+        total_amount = float(item_purchases['Amount (In Dollars)'].sum())
+        last_purchase = pd.to_datetime(item_purchases['Purchase_Date'].max())
+        category = product_categories.get(item, 'Unknown')
+        purchased_items_info.append({
+            'product_id': item,
+            'category': category,
+            'total_amount': total_amount,
+            'last_purchase': last_purchase.strftime('%Y-%m-%d')
+        })
+    
+    user_idx = purchase_counts.index.get_loc(user_id)
+    user_history = sparse_purchase_counts[user_idx].toarray().flatten()
+    similarities = cosine_similarities.dot(user_history)
+    purchased_indices = np.where(user_history > 0)[0]
+    similarities[purchased_indices] = 0
+    recommended_indices = np.argsort(similarities)[::-1][:n]
+    recommended_items = list(purchase_counts.columns[recommended_indices])
+    recommended_items = [item for item in recommended_items if item not in purchased_items]
+    
+    recommended_items_info = [
+        {
+            'product_id': item,
+            'category': product_categories.get(item, 'Unknown')
+        }
+        for item in recommended_items
+    ]
+
+    return purchased_items_info, recommended_items_info
 #return JSONResponse(content={"message": "Here's your interdimensional portal." , "mes1":"data2"})
 #https://vaibhav84-resumeapi.hf.space/docs
 #https://vaibhav84-resumeapi.hf.space/redoc d

sample.py

@@ -0,0 +1,123 @@
+import pandas as pd
+import numpy as np
+from sklearn.metrics.pairwise import cosine_similarity
+from scipy import sparse
+
+# Load the purchase history data from Excel file and convert Purchase_Date to datetime
+purchase_history = pd.read_excel('datasetsample.xlsx', sheet_name='Transaction History', 
+                               parse_dates=['Purchase_Date'])  # Add this parameter
+
+# Ensure Customer_Id is treated as string
+purchase_history['Customer_Id'] = purchase_history['Customer_Id'].astype(str)
+
+# Create a dictionary to store product categories
+product_categories = purchase_history[['Product_Id', 'Category']].drop_duplicates().set_index('Product_Id')['Category'].to_dict()
+
+# Count the number of purchases for each user and product combination
+purchase_counts = purchase_history.groupby(['Customer_Id', 'Product_Id']).size().unstack(fill_value=0)
+
+# Convert the purchase counts to a sparse matrix
+sparse_purchase_counts = sparse.csr_matrix(purchase_counts)
+
+# Compute the cosine similarity matrix between the products
+cosine_similarities = cosine_similarity(sparse_purchase_counts.T)
+
+def get_customer_items_and_recommendations(user_id, n=5):
+    """
+    Get both purchased items and recommendations for a user
+    
+    Parameters:
+    user_id (str): The customer ID as string
+    n (int): Number of recommendations to return
+    
+    Returns:
+    tuple: (purchased_items_info, recommended_items_info)
+    """
+    # Convert user_id to string if it's not already
+    user_id = str(user_id)
+    
+    # Check if user exists in the data
+    if user_id not in purchase_counts.index:
+        return [], []
+    
+    # Get purchased items
+    purchased_items = list(purchase_counts.columns[purchase_counts.loc[user_id] > 0])
+    
+    # Get purchased items details
+    purchased_items_info = []
+    user_purchases = purchase_history[purchase_history['Customer_Id'] == user_id]
+    for item in purchased_items:
+        item_purchases = user_purchases[user_purchases['Product_Id'] == item]
+        total_amount = item_purchases['Amount (In Dollars)'].sum()
+        last_purchase = pd.to_datetime(item_purchases['Purchase_Date'].max())  # Ensure datetime
+        category = product_categories.get(item, 'Unknown')
+        purchased_items_info.append({
+            'product_id': item,
+            'category': category,
+            'total_amount': total_amount,
+            'last_purchase': last_purchase
+        })
+    
+    # Get the user's index in the matrix
+    user_idx = purchase_counts.index.get_loc(user_id)
+    
+    # Get the user's purchase history
+    user_history = sparse_purchase_counts[user_idx].toarray().flatten()
+
+    # Compute similarities and get recommendations
+    similarities = cosine_similarities.dot(user_history)
+    purchased_indices = np.where(user_history > 0)[0]
+    similarities[purchased_indices] = 0
+    recommended_indices = np.argsort(similarities)[::-1][:n]
+    recommended_items = list(purchase_counts.columns[recommended_indices])
+    
+    # Remove any purchased items from recommendations
+    recommended_items = [item for item in recommended_items if item not in purchased_items]
+    
+    # Get recommended items details
+    recommended_items_info = [
+        {
+            'product_id': item,
+            'category': product_categories.get(item, 'Unknown')
+        }
+        for item in recommended_items
+    ]
+
+    return purchased_items_info, recommended_items_info
+
+def display_customer_profile(user_id, n=5):
+    """
+    Display customer's purchase history and recommendations with categories
+    
+    Parameters:
+    user_id (str): The customer ID as string
+    n (int): Number of recommendations to return
+    """
+    purchased_items_info, recommended_items_info = get_customer_items_and_recommendations(user_id, n)
+    
+    print(f"\nCustomer Profile for {user_id}")
+    print("-" * 70)
+    
+    print("\nPurchase History:")
+    if purchased_items_info:
+        print(f"{'Product ID':<15} {'Category':<20} {'Total Amount':>12} {'Last Purchase'}")
+        print("-" * 70)
+        for item in purchased_items_info:
+            print(f"{item['product_id']:<15} {item['category']:<20} ${item['total_amount']:>11.2f} {item['last_purchase'].strftime('%Y-%m-%d')}")
+    else:
+        print("No purchase history found")
+    
+    print("\nRecommended Items:")
+    if recommended_items_info:
+        print(f"{'Product ID':<15} {'Category':<20}")
+        print("-" * 35)
+        for item in recommended_items_info:
+            print(f"{item['product_id']:<15} {item['category']:<20}")
+    else:
+        print("No recommendations available")
+    
+    print("-" * 70)
+
+# Example usage:
+customer_id = 'CUST2025A'  # Replace with your actual customer ID
+display_customer_profile(customer_id)