Singular Value Decomposition Example 2 - Recommendation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Singular Value Decomposition Example - Recommendation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import pdb\n",
    "import warnings\n",
    "\n",
    "from numpy import *\n",
    "from numpy import linalg as la\n",
    "\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def euclidean_similarity(vector_a, vector_b):\n",
    "\n",
    "    euclidean_distance = np.linalg.norm(vector_a - vector_b) # Calculate the Euclidean distance\n",
    "    euclidean_similarity = 1.0 / (1.0 + euclidean_distance) # Convert the Euclidean distance to similarity\n",
    "    \n",
    "    return euclidean_similarity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pearson_similarity(vector_a, vector_b):\n",
    "\n",
    "    # Compute Pearson correlation coefficient between the two vectors\n",
    "    if len(vector_a) < 3:\n",
    "        pearson_similarity = 1.0\n",
    "    else:\n",
    "        pearson_similarity = 0.5 + 0.5 * np.corrcoef(vector_a, vector_b, rowvar = 0)[0][1]\n",
    "\n",
    "    return pearson_similarity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cosine_similarity(vector_a, vector_b):\n",
    " \n",
    "    dot_product = float(vector_a.T * vector_b) # Calculate the dot product between the two vectors\n",
    "    denominator  = la.norm(vector_a) * la.norm(vector_b) # Calculate the product of the magnitudes of the vectors\n",
    "\n",
    "    # Compute cosine similarity and scale it to the range [0, 1]\n",
    "    if denominator == 0:\n",
    "        cosine_similarity = 0\n",
    "    else:\n",
    "        cosine_similarity = 0.5 + 0.5 * (dot_product / denominator)\n",
    "\n",
    "    return cosine_similarity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define vectors as numpy arrays\n",
    "A = np.array([2, 3, 0, 1, 0, 4, -5])\n",
    "B = np.array([0, 1, 2, -4, 2, 0, 3])\n",
    "\n",
    "# Convert arrays to matrices\n",
    "A = mat(A)\n",
    "B = mat(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.08333333333333333\n"
     ]
    }
   ],
   "source": [
    "print(euclidean_similarity(A.T, B.T))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.2665380020120951\n"
     ]
    }
   ],
   "source": [
    "print(pearson_similarity(A.T, B.T))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3150010839748479\n"
     ]
    }
   ],
   "source": [
    "print(cosine_similarity(A.T, B.T))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def standard_estimate(dataMat, user, simMeas, item):\n",
    "\n",
    "    # Get the number of items\n",
    "    n = shape(dataMat)[1]\n",
    "\n",
    "    # Initialize totals for similarity and weighted ratings\n",
    "    SimTotal = 0.0\n",
    "    ratSimTotal = 0.0\n",
    "\n",
    "    for j in range(n):\n",
    "\n",
    "        # Get the rating of the current item by the user\n",
    "        userRating = dataMat[user, j]\n",
    "\n",
    "        if userRating == 0:\n",
    "            continue\n",
    "        \n",
    "        # Find users who rated both the target item and the current item\n",
    "        overLap = nonzero(logical_and(dataMat[:, item] > 0, dataMat[:, j] > 0))[0]\n",
    "        \n",
    "        # Calculate similarity\n",
    "        if len(overLap) == 0:\n",
    "            similarity = 0\n",
    "        else:\n",
    "            similarity = simMeas(dataMat[overLap, item], dataMat[overLap, j])\n",
    "\n",
    "        # Accumulate similarity and weighted rating totals\n",
    "        SimTotal += similarity\n",
    "        ratSimTotal += similarity * userRating\n",
    "\n",
    "    if SimTotal == 0:\n",
    "        return 0\n",
    "    else:\n",
    "        return ratSimTotal / SimTotal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def singular_value_decomposition_estimate(dataMat, user, simMeas, item):\n",
    "\n",
    "    # Get the number of items\n",
    "    n = shape(dataMat)[1]\n",
    "\n",
    "    # Initialize totals for similarity and weighted ratings\n",
    "    SimTotal = 0.0\n",
    "    ratSimTotal = 0.0\n",
    "\n",
    "    # Convert to a matrix form\n",
    "    data = mat(dataMat)\n",
    "\n",
    "    # Perform SVD on the data matrix\n",
    "    U, Sigma, VT = la.svd(data)\n",
    "\n",
    "    # Create a diagonal matrix\n",
    "    Sig4 = mat(eye(4) * Sigma[:4])\n",
    "\n",
    "    # Transform the original item data into a lower-dimensional space\n",
    "    xformedItems = data.T * U[:, :4] * Sig4.I\n",
    "\n",
    "    for j in range(n):\n",
    "\n",
    "        # Get the rating of the current item by the user\n",
    "        userRating = data[user, j]\n",
    "\n",
    "        if userRating == 0 or j == item:\n",
    "            continue\n",
    "        \n",
    "        # Calculate similarity between the target item and the current item in the reduced space\n",
    "        similarity = simMeas(xformedItems[item, :].T, xformedItems[j, :].T)\n",
    "\n",
    "        # Accumulate similarity and weighted rating totals\n",
    "        SimTotal += similarity\n",
    "        ratSimTotal += similarity * userRating\n",
    "\n",
    "    if SimTotal == 0:\n",
    "        return 0\n",
    "    else:\n",
    "        return ratSimTotal / SimTotal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recommend(dataMat, user, N = 3, simMeas = cosine_similarity, estMethod = standard_estimate):\n",
    "\n",
    "    # Find indices of items the user has not rated\n",
    "    unratedItems = nonzero(dataMat[user, :].A == 0)[1]\n",
    "\n",
    "    if len(unratedItems) == 0:\n",
    "        return 'You rated everything'\n",
    "    \n",
    "    # List to store\n",
    "    itemScores = []\n",
    "\n",
    "    for item in unratedItems:\n",
    "\n",
    "        # Estimate the score for the unrated item\n",
    "        estimatedScore = estMethod(dataMat, user, simMeas, item)\n",
    "\n",
    "        # Append the item and its estimated score\n",
    "        itemScores.append((item, estimatedScore))\n",
    "\n",
    "    return sorted(itemScores, key = lambda jj: jj[1], reverse = True)[:N]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_data():\n",
    "\n",
    "    matrix = [[0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 5],\n",
    "              [0, 0, 0, 3, 0, 4, 0, 0, 0, 0, 3],\n",
    "              [0, 0, 0, 0, 4, 0, 0, 1, 0, 4, 0],\n",
    "              [3, 3, 4, 0, 0, 0, 0, 2, 2, 0, 0],\n",
    "              [5, 4, 5, 0, 0, 0, 0, 5, 5, 0, 0],\n",
    "              [0, 0, 0, 0, 5, 0, 1, 0, 0, 5, 0],\n",
    "              [4, 3, 4, 0, 0, 0, 0, 5, 5, 0, 1],\n",
    "              [0, 0, 0, 4, 0, 4, 0, 0, 0, 0, 4],\n",
    "              [0, 0, 0, 2, 0, 2, 5, 0, 0, 1, 2],\n",
    "              [0, 0, 0, 0, 5, 0, 0, 0, 0, 4, 0],\n",
    "              [1, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0],\n",
    "              [2, 1, 0, 2, 0, 5, 3, 0, 1, 0, 1]]\n",
    "    \n",
    "    return(np.mat(matrix))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 0 0 4 0 0 0 0 5]\n",
      " [0 0 0 3 0 4 0 0 0 0 3]\n",
      " [0 0 0 0 4 0 0 1 0 4 0]\n",
      " [3 3 4 0 0 0 0 2 2 0 0]\n",
      " [5 4 5 0 0 0 0 5 5 0 0]\n",
      " [0 0 0 0 5 0 1 0 0 5 0]\n",
      " [4 3 4 0 0 0 0 5 5 0 1]\n",
      " [0 0 0 4 0 4 0 0 0 0 4]\n",
      " [0 0 0 2 0 2 5 0 0 1 2]\n",
      " [0 0 0 0 5 0 0 0 0 4 0]\n",
      " [1 0 0 0 0 0 0 1 2 0 0]\n",
      " [2 1 0 2 0 5 3 0 1 0 1]]\n"
     ]
    }
   ],
   "source": [
    "data = load_data()\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.45889187  0.03170418 -0.01809311  0.11036907]\n",
      " [-0.3622062   0.04692163 -0.01141864  0.04254964]\n",
      " [-0.45537578  0.10423397 -0.00800224 -0.05403528]\n",
      " [-0.051868   -0.39701598 -0.05950012  0.06753374]\n",
      " [-0.01726089 -0.08392364  0.71965471 -0.13098077]\n",
      " [-0.09964753 -0.67126432 -0.11207725 -0.04038616]\n",
      " [-0.04619366 -0.25745027  0.05860349  0.87744841]\n",
      " [-0.45397947  0.09523267  0.03757744 -0.09430203]\n",
      " [-0.46909953  0.0672883  -0.0131357   0.00911101]\n",
      " [-0.01955354 -0.10798751  0.67233514  0.01344801]\n",
      " [-0.09629148 -0.52832652 -0.09176174 -0.42505074]]\n"
     ]
    }
   ],
   "source": [
    "D = mat(data) # Convert to a matrix format\n",
    "U, Sigma, VT = la.svd(D) # Perform SVD on the matrix\n",
    "Sig4 = mat(eye(4) * Sigma[:4]) # Create a diagonal matrix\n",
    "xItems = data.T * U[:, :4] * Sig4.I # Transform the original items into a lower-dimensional space\n",
    "print(xItems)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(4, 5.0), (9, 5.0), (10, 4.804196825932594), (3, 4.666666666666667)]\n"
     ]
    }
   ],
   "source": [
    "user = 4\n",
    "recommendataion = recommend(data, user, N = 4, simMeas = cosine_similarity, estMethod = standard_estimate)\n",
    "print(recommendataion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recommended Item for User 4\n",
      "Item  4 with predicted rating:  5.0\n",
      "Item  9 with predicted rating:  5.0\n",
      "Item  10 with predicted rating:  4.8\n",
      "Item  3 with predicted rating:  4.67\n"
     ]
    }
   ],
   "source": [
    "print(\"Recommended Item for User\", user)\n",
    "for i, p in recommendataion:\n",
    "    print(\"Item \", i, \"with predicted rating: \", round(p, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(10, 4.808129974963377), (4, 4.807852789245039), (9, 4.8035168885389705), (5, 4.795384164777592)]\n"
     ]
    }
   ],
   "source": [
    "user = 4\n",
    "recommendataion = recommend(data, user, N = 4, simMeas = cosine_similarity, estMethod = singular_value_decomposition_estimate)\n",
    "print(recommendataion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recommended Item for User 4\n",
      "Item  10 with predicted rating:  4.81\n",
      "Item  4 with predicted rating:  4.81\n",
      "Item  9 with predicted rating:  4.8\n",
      "Item  5 with predicted rating:  4.8\n"
     ]
    }
   ],
   "source": [
    "print(\"Recommended Item for User\", user)\n",
    "for i, p in recommendataion:\n",
    "    print(\"Item \", i, \"with predicted rating: \", round(p, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}