diff -r 34feeb53c0ba -r 0315d9983cd0 main_marking2/danube.scala --- a/main_marking2/danube.scala Sun Jan 15 10:58:13 2023 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,196 +0,0 @@ -// Core Part about Movie Recommendations -// at Danube.co.uk -//======================================== - - -object CW7b { // for purposes of generating a jar - -import io.Source -import scala.util._ - - -// (1) Implement the function get_csv_url which takes an url-string -// as argument and requests the corresponding file. The two urls -// of interest are ratings_url and movies_url, which correspond -// to CSV-files. -// The function should return the CSV file appropriately broken -// up into lines, and the first line should be dropped (that is without -// the header of the CSV file). The result is a list of strings (lines -// in the file). - -def get_csv_url(url: String) : List[String] = { - val csv = Source.fromURL(url)("ISO-8859-1") - csv.mkString.split("\n").toList.drop(1) -} - -val ratings_url = """https://nms.kcl.ac.uk/christian.urban/ratings.csv""" -val movies_url = """https://nms.kcl.ac.uk/christian.urban/movies.csv""" - -// test cases - -//val ratings = get_csv_url(ratings_url) -//val movies = get_csv_url(movies_url) - -//ratings.length // 87313 -//movies.length // 9742 - -// (2) Implement two functions that process the CSV files. The ratings -// function filters out all ratings below 4 and returns a list of -// (userID, movieID) pairs. The movies function just returns a list -// of (movieId, title) pairs. - - -def process_ratings(lines: List[String]) : List[(String, String)] = { - for (cols <- lines.map(_.split(",").toList); - if (cols(2).toInt >= 4)) yield (cols(0), cols(1)) -} - -def process_movies(lines: List[String]) : List[(String, String)] = { - for (cols <- lines.map(_.split(",").toList)) yield (cols(0), cols(1)) -} - -// test cases - -//val good_ratings = process_ratings(ratings) -//val movie_names = process_movies(movies) - -//good_ratings.length //48580 -//movie_names.length // 9742 - -//============================================== -// Do not change anything below, unless you want -// to submit the file for the advanced part 3! -//============================================== - - -// (3) Implement a grouping function that calulates a map -// containing the userIds and all the corresponding recommendations -// (list of movieIds). This should be implemented in a tail -// recursive fashion, using a map m as accumulator. This map -// is set to Map() at the beginning of the claculation. - -def groupById(ratings: List[(String, String)], - m: Map[String, List[String]]) : Map[String, List[String]] = ratings match { - case Nil => m - case (id, mov) :: rest => { - val old_ratings = m.getOrElse (id, Nil) - val new_ratings = m + (id -> (mov :: old_ratings)) - groupById(rest, new_ratings) - } -} - -// test cases -//val ratings_map = groupById(good_ratings, Map()) -//val movies_map = movie_names.toMap - -//ratings_map.get("414").get.map(movies_map.get(_)) // most prolific recommender with 1227 positive ratings -//ratings_map.get("474").get.map(movies_map.get(_)) // second-most prolific recommender with 787 positive ratings -//ratings_map.get("214").get.map(movies_map.get(_)) // least prolific recommender with only 1 positive rating - - - -//(4) Implement a function that takes a ratings map and a movie_name as argument. -// The function calculates all suggestions containing -// the movie mov in its recommendations. It returns a list of all these -// recommendations (each of them is a list and needs to have mov deleted, -// otherwise it might happen we recommend the same movie). - -def favourites(m: Map[String, List[String]], mov: String) : List[List[String]] = - (for (id <- m.keys.toList; - if m(id).contains(mov)) yield m(id).filter(_ != mov)) - - - -// test cases -// movie ID "912" -> Casablanca (1942) -// "858" -> Godfather -// "260" -> Star Wars: Episode IV - A New Hope (1977) - -//favourites(ratings_map, "912").length // => 80 - -// That means there are 80 users that recommend the movie with ID 912. -// Of these 80 users, 55 gave a good rating to movie 858 and -// 52 a good rating to movies 260, 318, 593. - - -// (5) Implement a suggestions function which takes a rating -// map and a movie_name as arguments. It calculates all the recommended -// movies sorted according to the most frequently suggested movie(s) first. -def suggestions(recs: Map[String, List[String]], - mov_name: String) : List[String] = { - val favs = favourites(recs, mov_name).flatten - val favs_counted = favs.groupBy(identity).view.mapValues(_.size).toList - val favs_sorted = favs_counted.sortBy(_._2).reverse - favs_sorted.map(_._1) -} - -// test cases - -//suggestions(ratings_map, "912") -//suggestions(ratings_map, "912").length -// => 4110 suggestions with List(858, 260, 318, 593, ...) -// being the most frequently suggested movies - -// (6) Implement recommendations functions which generates at most -// *two* of the most frequently suggested movies. It Returns the -// actual movie names, not the movieIDs. - -def recommendations(recs: Map[String, List[String]], - movs: Map[String, String], - mov_name: String) : List[String] = - suggestions(recs, mov_name).take(2).map(movs.get(_).get) - - -// testcases - -// recommendations(ratings_map, movies_map, "912") -// => List(Godfather, Star Wars: Episode IV - A NewHope (1977)) - -//recommendations(ratings_map, movies_map, "260") -// => List(Star Wars: Episode V - The Empire Strikes Back (1980), -// Star Wars: Episode VI - Return of the Jedi (1983)) - -// recommendations(ratings_map, movies_map, "2") -// => List(Lion King, Jurassic Park (1993)) - -// recommendations(ratings_map, movies_map, "0") -// => Nil - -// recommendations(ratings_map, movies_map, "1") -// => List(Shawshank Redemption, Forrest Gump (1994)) - -// recommendations(ratings_map, movies_map, "4") -// => Nil (there are three ratings for this movie in ratings.csv but they are not positive) - -// (7) Calculate the recommendations for all movies according to -// what the recommendations function in (6) produces (this -// can take a few seconds). Put all recommendations into a list -// (of strings) and count how often the strings occur in -// this list. This produces a list of string-int pairs, -// where the first component is the movie name and the second -// is the number of how many times they were recommended. -// Sort all the pairs according to the number -// of times they were recommended (most recommended movie name -// first). - -def occurrences(xs: List[String]): List[(String, Int)] = - for (x <- xs.distinct) yield (x, xs.count(_ == x)) - -def most_recommended(recs: Map[String, List[String]], - movs: Map[String, String]) : List[(String, Int)] = { - val all = (for (name <- movs.toList.map(_._1)) yield { - recommendations(recs, movs, name) - }).flatten - val occs = occurrences(all) - occs.sortBy(_._2).reverse -} - - -//most_recommended(ratings_map, movies_map).take(3) -// => -// List((Matrix,698), -// (Star Wars: Episode IV - A New Hope (1977),402), -// (Jerry Maguire (1996),382)) - - -}