1 // Core Part about Movie Recommendations 

     2 // at Danube.co.uk

     3 //========================================

     4 

     5 

     6 object M2 { // for purposes of generating a jar

     7 

     8 import io.Source

     9 import scala.util._

    10 

    11 

    12 // (1) Implement the function get_csv_url which takes an url-string

    13 //     as argument and requests the corresponding file. The two urls

    14 //     of interest are ratings_url and movies_url, which correspond 

    15 //     to CSV-files.

    16 //     The function should return the CSV file appropriately broken

    17 //     up into lines, and the first line should be dropped (that is without

    18 //     the header of the CSV file). The result is a list of strings (lines

    19 //     in the file).

    20 

    21 def get_csv_url(url: String) : List[String] = {

    22   val csv = Source.fromURL(url)("ISO-8859-1")

    23   csv.mkString.split("\n").toList.drop(1)

    24 }

    25 

    26 val ratings_url = """https://nms.kcl.ac.uk/christian.urban/ratings.csv"""

    27 val movies_url = """https://nms.kcl.ac.uk/christian.urban/movies.csv"""

    28 

    29 // test cases

    30 

    31 //val ratings = get_csv_url(ratings_url)

    32 //val movies = get_csv_url(movies_url)

    33 

    34 //ratings.length  // 87313

    35 //movies.length   // 9742

    36 

    37 // (2) Implement two functions that process the CSV files. The ratings

    38 //     function filters out all ratings below 4 and returns a list of 

    39 //     (userID, movieID) pairs. The movies function just returns a list 

    40 //     of (movieId, title) pairs.

    41 

    42 

    43 def process_ratings(lines: List[String]) : List[(String, String)] = {

    44   for (cols <- lines.map(_.split(",").toList); 

    45        if (cols(2).toInt >= 4)) yield (cols(0), cols(1))  

    46 }

    47 

    48 def process_movies(lines: List[String]) : List[(String, String)] = {

    49   for (cols <- lines.map(_.split(",").toList)) yield (cols(0), cols(1))  

    50 }

    51 

    52 // test cases

    53 

    54 //val good_ratings = process_ratings(ratings)

    55 //val movie_names = process_movies(movies)

    56 

    57 //good_ratings.length   //48580

    58 //movie_names.length    // 9742

    59 

    60 

    61 // (3) Implement a grouping function that calulates a map

    62 //     containing the userIds and all the corresponding recommendations 

    63 //     (list of movieIds). This  should be implemented in a tail

    64 //     recursive fashion, using a map m as accumulator. This map

    65 //     is set to Map() at the beginning of the claculation.

    66 

    67 def groupById(ratings: List[(String, String)], 

    68               m: Map[String, List[String]]) : Map[String, List[String]] = ratings match {

    69   case Nil => m

    70   case (id, mov) :: rest => {

    71     val old_ratings = m.getOrElse (id, Nil)

    72     val new_ratings = m + (id -> (mov :: old_ratings))

    73     groupById(rest, new_ratings)

    74   }

    75 }

    76 

    77 // test cases

    78 //val ratings_map = groupById(good_ratings, Map())

    79 //val movies_map = movie_names.toMap

    80 

    81 //ratings_map.get("414").get.map(movies_map.get(_)) // most prolific recommender with 1227 positive ratings

    82 //ratings_map.get("474").get.map(movies_map.get(_)) // second-most prolific recommender with 787 positive ratings

    83 //ratings_map.get("214").get.map(movies_map.get(_)) // least prolific recommender with only 1 positive rating

    84 

    85 

    86 

    87 //(4) Implement a function that takes a ratings map and a movie_name as argument.

    88 // The function calculates all suggestions containing

    89 // the movie mov in its recommendations. It returns a list of all these

    90 // recommendations (each of them is a list and needs to have mov deleted, 

    91 // otherwise it might happen we recommend the same movie).

    92 

    93 def favourites(m: Map[String, List[String]], mov: String) : List[List[String]] = 

    94   (for (id <- m.keys.toList;

    95         if m(id).contains(mov)) yield m(id).filter(_ != mov))

    96 

    97 

    98 

    99 // test cases

   100 // movie ID "912" -> Casablanca (1942)

   101 //          "858" -> Godfather

   102 //          "260" -> Star Wars: Episode IV - A New Hope (1977)

   103 

   104 //favourites(ratings_map, "912").length  // => 80

   105 

   106 // That means there are 80 users that recommend the movie with ID 912.

   107 // Of these 80  users, 55 gave a good rating to movie 858 and

   108 // 52 a good rating to movies 260, 318, 593.

   109 

   110 

   111 // (5) Implement a suggestions function which takes a rating

   112 // map and a movie_name as arguments. It calculates all the recommended

   113 // movies sorted according to the most frequently suggested movie(s) first.

   114 def suggestions(recs: Map[String, List[String]], 

   115                     mov_name: String) : List[String] = {

   116   val favs = favourites(recs, mov_name).flatten

   117   val favs_counted = favs.groupBy(identity).view.mapValues(_.size).toList

   118   val favs_sorted = favs_counted.sortBy(_._2).reverse

   119   favs_sorted.map(_._1)

   120 }

   121 

   122 // test cases

   123 

   124 //suggestions(ratings_map, "912")

   125 //suggestions(ratings_map, "912").length  

   126 // => 4110 suggestions with List(858, 260, 318, 593, ...)

   127 //    being the most frequently suggested movies

   128 

   129 // (6) Implement recommendations functions which generates at most

   130 // *two* of the most frequently suggested movies. It Returns the 

   131 // actual movie names, not the movieIDs.

   132 

   133 def recommendations(recs: Map[String, List[String]],

   134                    movs: Map[String, String],

   135                    mov_name: String) : List[String] =

   136   suggestions(recs, mov_name).take(2).map(movs.get(_).get)                 

   137 

   138 

   139 // testcases

   140 

   141 // recommendations(ratings_map, movies_map, "912")

   142 //   => List(Godfather, Star Wars: Episode IV - A NewHope (1977))

   143 

   144 //recommendations(ratings_map, movies_map, "260")

   145 //   => List(Star Wars: Episode V - The Empire Strikes Back (1980), 

   146 //           Star Wars: Episode VI - Return of the Jedi (1983))

   147 

   148 // recommendations(ratings_map, movies_map, "2")

   149 //   => List(Lion King, Jurassic Park (1993))

   150 

   151 // recommendations(ratings_map, movies_map, "0")

   152 //   => Nil

   153 

   154 // recommendations(ratings_map, movies_map, "1")

   155 //   => List(Shawshank Redemption, Forrest Gump (1994))

   156 

   157 // recommendations(ratings_map, movies_map, "4")

   158 //   => Nil  (there are three ratings for this movie in ratings.csv but they are not positive)     

   159 

   160 

   161 }