Objective

• Your task is implement a matrix factorization method—such as singular value decomposition (SVD) or Alternating Least Squares (ALS)—in the context of a recommender system.

• You may approach this assignment in a number of ways. You are welcome to start with an existing recommender system written by yourself or someone else. Remember as always to cite your sources, so that you can be graded on what you added, not what you found.

Introduction

SVD can be thought of as a pre-processing step for feature engineering. You might easily start with thousands or millions of items, and use SVD to create a much smaller set of “k” items (e.g. 20 or 70).

• This project is based on the work done in Project 2

• In this project we will add SVD to further explore the recommender system. I have used the recommenderlab package.

Data Preparation

library(recommenderlab)  
library(dplyr)           
library(tidyr)           
library(ggplot2)         
library(ggrepel)         
library(tictoc)          

ratings <- read.csv("https://raw.githubusercontent.com/PriyaShaji/Data612/master/Project_2/ratings.csv") 

movies <- read.csv("https://raw.githubusercontent.com/PriyaShaji/Data612/master/Project_2/movies.csv")

Movie_Matrix <- ratings %>%
  select(-timestamp) %>%
  spread(movieId, rating)

row.names(Movie_Matrix) <- Movie_Matrix[,1]

Movie_Matrix <- Movie_Matrix[-c(1)]
Movie_Matrix <- as(as.matrix(Movie_Matrix), "realRatingMatrix")

Movie_Matrix

## 610 x 9724 rating matrix of class 'realRatingMatrix' with 100836 ratings.

set.seed(88)
eval <- evaluationScheme(Movie_Matrix, method = "split",
                         train = 0.8, given= 20, goodRating=3)
train <- getData(eval, "train")
known <- getData(eval, "known")
unknown <- getData(eval, "unknown")

Algorithms Used

tic("UBCF Model - Training")
modelUBCF <- Recommender(train, method = "UBCF")
toc(log = TRUE, quiet = TRUE)

tic("UBCF Model - Predicting")
predUBCF <- predict(modelUBCF, newdata = known, type = "ratings")
toc(log = TRUE, quiet = TRUE)

( accUBCF <- calcPredictionAccuracy(predUBCF, unknown) )

##      RMSE       MSE       MAE 
## 0.9320803 0.8687737 0.7174840

tic("SVD Model - Training")
modelSVD <- Recommender(train, method = "SVD", parameter = list(k = 50))
toc(log = TRUE, quiet = TRUE)

tic("SVD Model - Predicting")
predSVD <- predict(modelSVD, newdata = known, type = "ratings")
toc(log = TRUE, quiet = TRUE)

( accSVD <- calcPredictionAccuracy(predSVD, unknown) )

##      RMSE       MSE       MAE 
## 0.9361910 0.8764536 0.7210165

log <- as.data.frame(unlist(tic.log(format = TRUE)))
colnames(log) <- c("Run Time")
knitr::kable(log, format = "html") %>%
  kableExtra::kable_styling(bootstrap_options = c("striped", "hover"))

Evaluation

Now let us evaluate our predictions by seeing the prediction matrix of a particular user.

Here, let’s see for user 400th.

mov_rated <- as.data.frame(Movie_Matrix@data[c("400"), ]) 
colnames(mov_rated) <- c("Rating")
mov_rated$movieId <- as.integer(rownames(mov_rated))
mov_rated <- mov_rated %>% filter(Rating != 0) %>% 
  inner_join (movies, by="movieId") %>%
  arrange(Rating) %>%
  select(Movie = "title", Rating)
knitr::kable(mov_rated, format = "html") %>%
  kableExtra::kable_styling(bootstrap_options = c("striped", "hover"))

• As we see that user 400th movie likes comes under action , low on romantic , dramatic movie genre categories.

• Now we can see the movies suggested by SVD to user 400th.

mov_recommend <- as.data.frame(predSVD@data[c("400"), ]) 
colnames(mov_recommend) <- c("Rating")
mov_recommend$movieId <- as.integer(rownames(mov_recommend))
mov_recommend <- mov_recommend %>% arrange(desc(Rating)) %>% head(6) %>% 
  inner_join (movies, by="movieId") %>%
  select(Movie = "title")
knitr::kable(mov_recommend, format = "html") %>%
  kableExtra::kable_styling(bootstrap_options = c("striped", "hover"))

Therefore by analyzing top 6 movies being recommended to user 400th, we see that they also are action and drama genre movie categories.

Singular Value Decomposition(Manual)

# Normalize matrix
movieMatrix <- as.matrix(normalize(Movie_Matrix)@data)

# Perform SVD
movieSVD <- svd(movieMatrix)
rownames(movieSVD$u) <- rownames(movieMatrix)
rownames(movieSVD$v) <- colnames(movieMatrix)

# Reduce dimensions
n <- length(movieSVD$d)
total_energy <- sum(movieSVD$d^2)
for (i in (n-1):1) {
  energy <- sum(movieSVD$d[1:i]^2)
  if (energy/total_energy<0.9) {
    n_dims <- i+1
    break
  }
}

trim_mov_D <- movieSVD$d[1:n_dims]
trim_mov_U <- movieSVD$u[, 1:n_dims]
trim_mov_V <- movieSVD$v[, 1:n_dims]

head(trim_mov_D)

## [1] 76.20047 43.62240 41.77917 39.37051 37.95619 36.54896

mov_count <- 5

movies_df <- as.data.frame(trim_mov_V) %>% select(V1, V2)
movies_df$movieId <- as.integer(rownames(movies_df))

mov_sample <- movies_df %>% arrange(V1) %>% head(mov_count)
mov_sample <- rbind(mov_sample, movies_df %>% arrange(desc(V1)) %>% head(mov_count))
mov_sample <- rbind(mov_sample, movies_df %>% arrange(V2) %>% head(mov_count))
mov_sample <- rbind(mov_sample, movies_df %>% arrange(desc(V2)) %>% head(mov_count))
mov_sample <- mov_sample %>% inner_join(movies, by = "movieId") %>% 
  select(Movie = "title", Concept1 = "V1", Concept2 = "V2")
mov_sample$Concept1 <- round(mov_sample$Concept1, 4)
mov_sample$Concept2 <- round(mov_sample$Concept2, 4)

knitr::kable(mov_sample, format = "html") %>%
  kableExtra::kable_styling(bootstrap_options = c("striped", "hover"))

Summary

Collaborative Filtering:

• It successfully avoids the problem posed by dynamic user preference as item-based CF is more static.

• However, several problems remain for this method. First, the main issue is scalability. The computation grows with both the customer and the product. The worst case complexity is O(mn) with m users and n items.

Singular Value Decomposition:

• SVD decreases the dimension of the utility matrix by extracting its latent factors.

• SVD handles the problem of scalability and sparsity posed by CF successfully. However, SVD is not without flaw. The main drawback of SVD is that there is no to little explanation to the reason that we recommend an item to a user. This can be a huge problem if users are eager to know why a specific item is recommended to them.

Reference

Introduction to Recommender System