# HG changeset patch # User Christian Urban # Date 1542721352 0 # Node ID 092e0879a5ae4e59c8d356866d99ee7b5144bd5c # Parent 63a1376cbebd4c81b79eb21f5cebfea12e50e292 updated diff -r 63a1376cbebd -r 092e0879a5ae testing2/danube.scala --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/testing2/danube.scala Tue Nov 20 13:42:32 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 63a1376cbebd -r 092e0879a5ae testing2/danube_test.sh --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/testing2/danube_test.sh Tue Nov 20 13:42:32 2018 +0000 @@ -0,0 +1,99 @@ +#!/bin/bash + +# to make the script fail safely +set -euo pipefail + + +out=${1:-output} + +echo "" > $out + +echo "Below is the feedback for your submission danube.scala" >> $out +echo "" >> $out + + +# compilation tests + +function scala_compile { + (ulimit -t 30; JAVA_OPTS="-Xmx1g" scala "$1" 2>> $out 1>> $out) +} + +# functional tests + +function scala_assert { + (ulimit -t 30; JAVA_OPTS="-Xmx1g" scala -i "$1" "$2" -e "" 2> /dev/null 1> /dev/null) +} + +# purity test + +function scala_vars { + (egrep '\bvar\b|\breturn\b|\.par|ListBuffer|mutable' "$1" 2> /dev/null 1> /dev/null) +} + + +# var, .par return, ListBuffer test +# +echo "danube.scala does not contain vars, returns etc?" >> $out + +if (scala_vars danube.scala) +then + echo " --> fail (make triple-sure your program conforms to the required format)" >> $out + tsts0=$(( 0 )) +else + echo " --> success" >> $out + tsts0=$(( 0 )) +fi + +### compilation test + + +if [ $tsts0 -eq 0 ] +then + echo "danube.scala runs?" >> $out + + if (scala_compile danube.scala) + then + echo " --> success" >> $out + tsts=$(( 0 )) + else + echo " --> scala did not run danube.scala" >> $out + tsts=$(( 1 )) + fi +else + tsts=$(( 1 )) +fi + +### danube get_cvs_url tests + +if [ $tsts -eq 0 ] +then + echo "danube.scala tests:" >> $out + echo " val movies_url = \"\"\"https://nms.kcl.ac.uk/christian.urban/movies.csv\"\"\"" >> $out + echo " get_csv_url(movies_url).length == 9742" >> $out + + if (scala_assert "danube.scala" "danube_test1.scala") + then + echo " --> success" >> $out + else + echo " --> one of the tests failed" >> $out + fi +fi + +### danube processing tests + +if [ $tsts -eq 0 ] +then + echo " val good_ratings = process_ratings(ratings)" >> $out + echo " val movie_names = process_movies(movies)" >> $out + echo " " >> $out + echo " good_ratings.length == 48580 " >> $out + echo " movie_names.length == 9742 " >> $out + + if (scala_assert "danube.scala" "danube_test2.scala") + then + echo " --> success" >> $out + else + echo " --> one of the tests failed" >> $out + fi +fi + diff -r 63a1376cbebd -r 092e0879a5ae testing2/danube_test1.scala --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/testing2/danube_test1.scala Tue Nov 20 13:42:32 2018 +0000 @@ -0,0 +1,5 @@ + +val urban_mov_url = """https://nms.kcl.ac.uk/christian.urban/movies.csv""" + +assert(get_csv_url(urban_mov_url).length == 9742) + diff -r 63a1376cbebd -r 092e0879a5ae testing2/danube_test2.scala --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/testing2/danube_test2.scala Tue Nov 20 13:42:32 2018 +0000 @@ -0,0 +1,18 @@ + +import io.Source +import scala.util._ + +def urban_get_csv_file(name: String) : List[String] = { + val csv = Source.fromFile(name) + csv.mkString.split("\n").toList.drop(1) +} + +val urban_ratings = urban_get_csv_file("ratings.csv") +val urban_movies = urban_get_csv_file("movies.csv") + + +assert(process_ratings(urban_ratings).length == 48580) + +assert(process_movies(urban_movies).length == 9742) + + diff -r 63a1376cbebd -r 092e0879a5ae testing2/docdiff.scala --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/testing2/docdiff.scala Tue Nov 20 13:42:32 2018 +0000 @@ -0,0 +1,117 @@ +// Part 1 about Code Similarity +//============================== + + +//object CW7a { // for purposes of generating a jar + +//(1) Complete the clean function below. It should find +// all words in a string using the regular expression +// \w+ and the library function +// +// some_regex.findAllIn(some_string) +// +// The words should be Returned as a list of strings. + +def clean(s: String) : List[String] = + ("""\w+""".r).findAllIn(s).toList + + +//(2) The function occurrences calculates the number of times +// strings occur in a list of strings. These occurrences should +// be calculated as a Map from strings to integers. + +def occurrences(xs: List[String]): Map[String, Int] = + (for (x <- xs.distinct) yield (x, xs.count(_ == x))).toMap + +//(3) This functions calculates the dot-product of two documents +// (list of strings). For this it calculates the occurrence +// maps from (2) and then multiplies the corresponding occurrences. +// If a string does not occur in a document, the product is zero. +// The function finally sums up all products. + +def prod(lst1: List[String], lst2: List[String]) : Int = { + val words = (lst1 ::: lst2).distinct + val occs1 = occurrences(lst1) + val occs2 = occurrences(lst2) + words.map{ w => occs1.getOrElse(w, 0) * occs2.getOrElse(w, 0) }.sum +} + +//(4) Complete the functions overlap and similarity. The overlap of +// two documents is calculated by the formula given in the assignment +// description. The similarity of two strings is given by the overlap +// of the cleaned (see (1)) strings. + +def overlap(lst1: List[String], lst2: List[String]) : Double = { + val m1 = prod(lst1, lst1) + val m2 = prod(lst2, lst2) + prod(lst1, lst2).toDouble / (List(m1, m2).max) +} + +def similarity(s1: String, s2: String) : Double = + overlap(clean(s1), clean(s2)) + + +/* + + +val list1 = List("a", "b", "b", "c", "d") +val list2 = List("d", "b", "d", "b", "d") + +occurrences(List("a", "b", "b", "c", "d")) // Map(a -> 1, b -> 2, c -> 1, d -> 1) +occurrences(List("d", "b", "d", "b", "d")) // Map(d -> 3, b -> 2) + +prod(list1,list2) // 7 + +overlap(list1, list2) // 0.5384615384615384 +overlap(list2, list1) // 0.5384615384615384 +overlap(list1, list1) // 1.0 +overlap(list2, list2) // 1.0 + +// Plagiarism examples from +// https://desales.libguides.com/avoidingplagiarism/examples + +val orig1 = """There is a strong market demand for eco-tourism in +Australia. Its rich and diverse natural heritage ensures Australia's +capacity to attract international ecotourists and gives Australia a +comparative advantage in the highly competitive tourism industry.""" + +val plag1 = """There is a high market demand for eco-tourism in +Australia. Australia has a comparative advantage in the highly +competitive tourism industry due to its rich and varied natural +heritage which ensures Australia's capacity to attract international +ecotourists.""" + +similarity(orig1, plag1) + + +// Plagiarism examples from +// https://www.utc.edu/library/help/tutorials/plagiarism/examples-of-plagiarism.php + +val orig2 = """No oil spill is entirely benign. Depending on timing and +location, even a relatively minor spill can cause significant harm to +individual organisms and entire populations. Oil spills can cause +impacts over a range of time scales, from days to years, or even +decades for certain spills. Impacts are typically divided into acute +(short-term) and chronic (long-term) effects. Both types are part of a +complicated and often controversial equation that is addressed after +an oil spill: ecosystem recovery.""" + +val plag2 = """There is no such thing as a "good" oil spill. If the +time and place are just right, even a small oil spill can cause damage +to sensitive ecosystems. Further, spills can cause harm days, months, +years, or even decades after they occur. Because of this, spills are +usually broken into short-term (acute) and long-term (chronic) +effects. Both of these types of harm must be addressed in ecosystem +recovery: a controversial tactic that is often implemented immediately +following an oil spill.""" + +overlap(clean(orig2), clean(plag2)) +similarity(orig2, plag2) + +// The punchline: everything above 0.6 looks suspicious and +// should be looked at by staff. + +*/ + + +//} diff -r 63a1376cbebd -r 092e0879a5ae testing2/docdiff_test.sh --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/testing2/docdiff_test.sh Tue Nov 20 13:42:32 2018 +0000 @@ -0,0 +1,136 @@ +#!/bin/bash + +# to make the script fail safely +set -euo pipefail + + +out=${1:-output} + +echo "" > $out + +echo "Below is the feedback for your submission docdiff.scala" >> $out +echo "" >> $out + + +# compilation tests + +function scala_compile { + (ulimit -t 30; JAVA_OPTS="-Xmx1g" scala "$1" 2>> $out 1>> $out) +} + +# functional tests + +function scala_assert { + (ulimit -t 30; JAVA_OPTS="-Xmx1g" scala -i "$1" "$2" -e "" 2> /dev/null 1> /dev/null) +} + +# purity test + +function scala_vars { + (egrep '\bvar\b|\breturn\b|\.par|ListBuffer|mutable' "$1" 2> /dev/null 1> /dev/null) +} + + +# var, .par return, ListBuffer test +# +echo "docdiff.scala does not contain vars, returns etc?" >> $out + +if (scala_vars docdiff.scala) +then + echo " --> fail (make triple-sure your program conforms to the required format)" >> $out + tsts0=$(( 0 )) +else + echo " --> success" >> $out + tsts0=$(( 0 )) +fi + +### compilation test + + +if [ $tsts0 -eq 0 ] +then + echo "docdiff.scala runs?" >> $out + + if (scala_compile docdiff.scala) + then + echo " --> success" >> $out + tsts=$(( 0 )) + else + echo " --> scala did not run docdiff.scala" >> $out + tsts=$(( 1 )) + fi +else + tsts=$(( 1 )) +fi + +### docdiff clean tests + +if [ $tsts -eq 0 ] +then + echo "docdiff.scala tests:" >> $out + echo " clean(\"ab a abc\") == List(\"ab\", \"a\", \"abc\")" >> $out + echo " clean(\"ab*a abc1\") == List(\"ab\", \"a\", \"abc1\")" >> $out + + if (scala_assert "docdiff.scala" "docdiff_test1.scala") + then + echo " --> success" >> $out + else + echo " --> one of the tests failed" >> $out + fi +fi + +### docdiff occurrences tests + +if [ $tsts -eq 0 ] +then + echo " occurrences(List(\"a\", \"b\", \"b\", \"c\", \"d\")) == " >> $out + echo " Map(\"a\" -> 1, \"b\" -> 2, \"c\" -> 1, \"d\" -> 1)" >> $out + echo " " >> $out + echo " occurrences(List(\"d\", \"b\", \"d\", \"b\", \"d\")) == " >> $out + echo " Map(\"d\" -> 3, \"b\" -> 2)" >> $out + + if (scala_assert "docdiff.scala" "docdiff_test2.scala") + then + echo " --> success" >> $out + else + echo " --> one of the tests failed" >> $out + fi +fi + +### docdiff prod tests + +if [ $tsts -eq 0 ] +then + echo " val l1 = List(\"a\", \"b\", \"b\", \"c\", \"d\")" >> $out + echo " val l2 = List(\"d\", \"b\", \"d\", \"b\", \"d\")" >> $out + echo " " >> $out + echo " prod(l1, l2) == 7 " >> $out + echo " prod(l1, l1) == 7 " >> $out + echo " prod(l2, l2) == 13 " >> $out + + if (scala_assert "docdiff.scala" "docdiff_test3.scala") + then + echo " --> success" >> $out + else + echo " --> one of the tests failed" >> $out + fi +fi + +### docdiff overlap tests + +if [ $tsts -eq 0 ] +then + echo " val l1 = List(\"a\", \"b\", \"b\", \"c\", \"d\")" >> $out + echo " val l2 = List(\"d\", \"b\", \"d\", \"b\", \"d\")" >> $out + echo " " >> $out + echo " overlap(l1, l2) == 0.5384615384615384 " >> $out + echo " overlap(l1, l1) == 1.0 " >> $out + echo " overlap(l2, l2) == 1.0 " >> $out + + if (scala_assert "docdiff.scala" "docdiff_test4.scala") + then + echo " --> success" >> $out + else + echo " --> one of the tests failed" >> $out + fi +fi diff -r 63a1376cbebd -r 092e0879a5ae testing2/docdiff_test1.scala --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/testing2/docdiff_test1.scala Tue Nov 20 13:42:32 2018 +0000 @@ -0,0 +1,6 @@ + + +assert(clean("ab a abc") == List("ab", "a", "abc")) + + +assert(clean("ab*a abc1") == List("ab", "a", "abc1")) diff -r 63a1376cbebd -r 092e0879a5ae testing2/docdiff_test2.scala --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/testing2/docdiff_test2.scala Tue Nov 20 13:42:32 2018 +0000 @@ -0,0 +1,5 @@ + + +assert(occurrences(List("a", "b", "b", "c", "d")) == Map("a" -> 1, "b" -> 2, "c" -> 1, "d" -> 1)) + +assert(occurrences(List("d", "b", "d", "b", "d")) == Map("d" -> 3, "b" -> 2)) diff -r 63a1376cbebd -r 092e0879a5ae testing2/docdiff_test3.scala --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/testing2/docdiff_test3.scala Tue Nov 20 13:42:32 2018 +0000 @@ -0,0 +1,10 @@ + + +val urban_list1 = List("a", "b", "b", "c", "d") +val urban_list2 = List("d", "b", "d", "b", "d") + +assert(prod(urban_list1, urban_list2) == 7) + +assert(prod(urban_list1, urban_list1) == 7) + +assert(prod(urban_list2, urban_list2) == 13) diff -r 63a1376cbebd -r 092e0879a5ae testing2/docdiff_test4.scala --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/testing2/docdiff_test4.scala Tue Nov 20 13:42:32 2018 +0000 @@ -0,0 +1,10 @@ + + +val urban_list1 = List("a", "b", "b", "c", "d") +val urban_list2 = List("d", "b", "d", "b", "d") + +assert(overlap(urban_list1, urban_list2) == 0.5384615384615384) + +assert(overlap(urban_list1, urban_list1) == 1.0) + +assert(overlap(urban_list2, urban_list2) == 1.0)