Business

We choose to limit the scope to our recommender system to only businesses with tags related to food and beverages. There were originally 508 unique category tags listed within our business data. We manually filtered 112 targeted categories to subset our data.

We applied additional transformation to remove unnecessary data. There were 1,224 business in our data that were permanently closed. These companies accounted for 9.8% of all businesses, which were subsequently removed from our data. There were also 3 businesses in our data set from outside of AZ that we also removed.

As a result of our transformations, our recommender data was shortened 4,828 unique businesses. This was further limited to 4,332 after randomly sampling our user-data. The output of which can be previewed below:

Review

We subset our review data from the subset of food and beverage businesses. This dropped our review data from 229,907 to 165,823 reviews. We later applied another filter to the data to only use reviews from 10,000 randomly sampled users. This further decreases reviews to 44,494 observations. Our review data can be previewed in two parts below:

User

Next, we applied a similar filter to users to subset our data based on only our selected businesses. This decreased our user data from 43,873 to 35,268 distinct user_id observations. Do to processing constraints in R, we choose to randomly sample 10,000 users from these unique profiles.

The data frame preview below shows aggregate user data for all reviews an individual user provided for yelp within our data selection.

Merged Dataframe

Last, we created our main data frame by merging business and reviews on Business_ID. This data frame will serve as the source of data for our recommender algorithms. The user and business unique keys were simplified from characters to numeric user/item identifiers.

This data frame will be referenced later on when building our recommender matrices and algorithms.

Matrix Building

We converted our raw ratings data into a user-item matrix to test and train our subsequent recommender system algorithms. The matrix was saved as a realRatingMatrix for processing purposes later on using the recommenderlab package.

# spread data from long to wide format 
matrix_data <- df %>% select(userID, itemID, stars) %>% spread(itemID, stars)
# set row names to userid
rownames(matrix_data)<-matrix_data$userID 
# remove userid from columns 
matrix_data <-matrix_data %>% select(-userID) 
# randomize dataframe
set.seed(1)
matrix_data <- matrix_data[sample(nrow(matrix_data)),]
# convert to matrix
ui_mat <- matrix_data %>% as.matrix()
# store matrix as realRatingMatrix
ui_mat <- as(ui_mat,"realRatingMatrix")

Train and Test Splits

Our data was split into training and tests sets for model evaluation of both two recommender algorithms. We split our data with 5 k-folds. 80% of data was retained for training and 20% for testing purposes.

# evaluation method with 80% of data for train and 20% for test
set.seed(1)

evalu <- evaluationScheme(ui_mat, method="split", train=0.8, given=1, goodRating=4, k=5)

# prep data
train <- getData(evalu, 'train')# Training Dataset 
dev_test <- getData(evalu, 'known') # Test data from evaluationScheme of type KNOWN
test <- getData(evalu, 'unknown') # Unknow datset used for RMSE / model evaluation

User-based CF

In our first example, user-based CF is used to create recommendations with the recommender lab package in R. We start by training our recommender with the train set, with our data being normalized with the Z-score and using cosine similarity for comparisons.

We then create our predictions using the dev-test set with ratings as our prediction output. It is imperative to set a floor and ceiling as sometimes predictions will fall outside of our ratings scale of 1-5.

Finally we calculated the prediction accuracy against the test data

# using recommender lab, create UBCF recommender with z-score normalized data using cosine similarity
UB <- Recommender(getData(evalu, "train"), "UBCF", 
      param=list(normalize = "Z-score",method="Cosine"))

# create rating predictions and store
p <- predict(UB, getData(evalu, "known"), type="ratings")

# set floor and ceiling for ratings that fall outside scale
p@data@x[p@data@x[] < 1] <- 1
p@data@x[p@data@x[] > 5] <- 5

# calculate the prediction accurary based on our test data
UB_acc <- calcPredictionAccuracy(p, getData(evalu, "unknown"))

Item-based CF

This is the same process as above except this time we are using an item-based collaborative filtering to create our recommendations.

IB <- Recommender(getData(evalu, "train"), "IBCF", 
      param=list(normalize = "Z-score",method="Cosine"))

p1 <- predict(IB, getData(evalu, "known"), type="ratings")

p1@data@x[p1@data@x[] < 1] <- 1
p1@data@x[p1@data@x[] > 5] <- 5

IB_acc <- calcPredictionAccuracy(p1, getData(evalu, "unknown"))

Performance

After our analysis we see that User-based CF outperforms Item-based CF in all error metrics. Considering the size of our data set the RMSE is relatively low.

# print out errors in table
error <- rbind(UB_acc,IB_acc)
error 

##            RMSE      MSE       MAE
## UB_acc 1.337380 1.788585 0.9812829
## IB_acc 1.473754 2.171951 1.1263370

Connecting

We initiated a local connection with Spark (V2.4.3). Our yelp data was inputted into a spark table and split for training and testing purposes. We uploaded our training and test splits to minimize the variance in our comparisons.

# configure spark connection
config <- spark_config()
config$spark.executor.memory <- "8G"
config$spark.executor.cores <- 2
config$spark.executor.instances <- 3
config$spark.dynamicAllocation.enabled <- "false"

# initiate connection
sc <- spark_connect(master = "local", config=config, version = "2.4.3")

# unhash to verify version: 
# spark_version(sc)

# select data for spark and create spark table 
spark_train <- as(train,"data.frame")
spark_test<- as(test,"data.frame") 

spark_train <- sdf_copy_to(sc, spark_train, "spark_train", overwrite = TRUE) 
spark_test <- sdf_copy_to(sc, spark_test, "spark_test", overwrite = TRUE) 

# Transform features
spark_train <- spark_train %>%
  ft_string_indexer(input_col = "user", output_col = "user_index") %>%
  ft_string_indexer(input_col = "item", output_col = "item_index") %>%
  sdf_register("spark_train")
  
spark_test <- spark_test %>%
  ft_string_indexer(input_col = "user", output_col = "user_index") %>%
  ft_string_indexer(input_col = "item", output_col = "item_index") %>%
  sdf_register("spark_test")

ALS

Once connected, we applied the alternating least squares (ALS) for our recommender predictions.

# build model using user/business/ratings
als_fit <- ml_als(spark_train, 
                  max_iter = 5, 
                  nonnegative = TRUE, 
                  rank = 2,
                  rating_col = "rating", 
                  user_col = "user_index", 
                  item_col = "item_index")

# predict from the model for the training data
als_predict_train <- ml_predict(als_fit, spark_train) %>% collect()
als_predict_test <- ml_predict(als_fit, spark_test) %>% collect()

# Remove NaN (result of test/train splits - not data)
als_predict_train <- als_predict_train[!is.na(als_predict_train$prediction), ] 
als_predict_test <- als_predict_test[!is.na(als_predict_test$prediction), ]

# Set floor/ceiling for predictions
als_predict_train$prediction[als_predict_train$prediction < 1] <- 1
als_predict_train$prediction[als_predict_train$prediction > 5] <- 5
als_predict_test$prediction[als_predict_test$prediction < 1] <- 1
als_predict_test$prediction[als_predict_test$prediction > 5] <- 5

# View results
als_predict_test %>% head() %>% kable() %>% kable_styling()

Performance

Our ALS calculations for RMSE, MSE, and MAE can be viewed below:

# Calculate RMSE/MSE/MAE 
als_mse_train <- mean((als_predict_train$rating - als_predict_train$prediction)^2)
als_rmse_train <- sqrt(als_mse_train)
als_mae_train <- mean(abs(als_predict_train$rating - als_predict_train$prediction))

als_mse_test <- mean((als_predict_test$rating - als_predict_test$prediction)^2)
als_rmse_test <- sqrt(als_mse_test)
als_mae_test <- mean(abs(als_predict_test$rating - als_predict_test$prediction))

Recommendations

The ml_recommend function allows us to see the top n user recommendations for each user/item. Below, we use this function and filtered our recommendations to show the top 10 restaurant recommendations for a selected user.

als_user_recommend<-ml_recommend(als_fit, type="users", n=10)

## NULL