# HG changeset patch # User Christian Urban # Date 1542468950 0 # Node ID 40bdf9064e13258591d789177608769f078666ec # Parent f8883f8a14ad1db5eab5307cf96ba4217bc6f1fe updated diff -r f8883f8a14ad -r 40bdf9064e13 marking1/mk --- a/marking1/mk Sat Nov 17 13:35:08 2018 +0000 +++ b/marking1/mk Sat Nov 17 15:35:50 2018 +0000 @@ -3,7 +3,7 @@ trap "exit" INT -files=${1:-assignment20176-*} +files=${1:-assignment20186-*} for sd in $files; do cd $sd diff -r f8883f8a14ad -r 40bdf9064e13 solutions2/danube.jar Binary file solutions2/danube.jar has changed diff -r f8883f8a14ad -r 40bdf9064e13 solutions2/danube.scala --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/solutions2/danube.scala Sat Nov 17 15:35:50 2018 +0000 @@ -0,0 +1,177 @@ +// Part 2 and 3 about Movie Recommendations +// at Danube.co.uk +//=========================================== + +import io.Source +import scala.util._ + +object CW7b { // for purposes of generating a jar + +// (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).toFloat >= 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).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 fro this movie in ratings.csv but they are not positive) + + +// If you want to calculate the recomendations for all movies. +// Will take a few seconds calculation time. + +//val all = for (name <- movie_names.map(_._1)) yield { +// recommendations(ratings_map, movies_map, name) +//} + +// helper functions +//List().take(2 +//List(1).take(2) +//List(1,2).take(2) +//List(1,2,3).take(2) + +} diff -r f8883f8a14ad -r 40bdf9064e13 solutions2/docdiff.jar Binary file solutions2/docdiff.jar has changed