{"id":1842,"date":"2010-04-15T11:08:49","date_gmt":"2010-04-15T09:08:49","guid":{"rendered":"http:\/\/blog.jteam.nl\/?p=1842"},"modified":"2010-04-15T11:08:49","modified_gmt":"2010-04-15T09:08:49","slug":"mahout-taste-part-two-getting-started","status":"publish","type":"post","link":"https:\/\/trifork.nl\/blog\/mahout-taste-part-two-getting-started\/","title":{"rendered":"Mahout – Taste :: Part Two – Getting started"},"content":{"rendered":"
This blog is a ‘getting started’ article and shows you how to build a simple web-based movie recommender with Mahout \/ Taste, Wicket and the Movielens dataset from Grouplens research group at the University of Minnesota. I will discuss which components you need, how to wire them up in Spring, and how to create a Wicket frontend for displaying movies and their recommendations. Along the way I give some tips and pointers about developing a recommender. Additionally I show the ResourceDataModel<\/span>, a Mahout DataModel<\/span> implementation which reads preferences from a Spring Resource<\/span>.
\n <\/strong><\/p>\n

Online movie store<\/strong><\/h3>\n

Our running example for this post is an online DVD shop in which you can view and rent movies. Visitors go to a movie’s page to check out the plot description and will be shown a list of similar movies. These are other movies that were watched by people who also rented that specific movie. Because of space- and time-constraints, this application only provides a view on the dataset and the recommended movies. Other features expected of an online movie rental service, such as registration and payment are left out.<\/p>\n

Movielens Dataset<\/strong><\/h3>\n

The movies and their ratings originate from the Movielens dataset<\/a> of the Grouplens research group<\/a> from the University of Minnesota. There are datasets contains 100.000, 1 million and 10 million ratings. Note that these ratings are explicit<\/em>, ranging from 1 to 5. This is different from the example in my earlier blog<\/a>, which featured implicit<\/em> ratings. Implicit ratings only indicate if a user purchased or liked an item but not how much someone liked it. In this example I used the 100.000 ratings file.<\/p>\n

Item-based or user-based algorithms<\/strong><\/h3>\n

For this application we use an item-based recommender, which is a good choice performance-wise if the number of items is less than the number of users. This is likely to be the case for an online movie rental store. Item-based recommendation is different from user-based recommendation, which works by identifying a user neighbourhood of similar users and recommending items from the user neighbourhood to other users. User-based recommendations are personalized<\/em> while with item-based recommendations each user will get the same recommendations for a given item<\/em>. In our case, all users that visit a specific movie page will see the same recommended movies for that movie. An example of user-based recommendation is Stumbleupon<\/a>, which provides personalized website recommendations. Stumbleupon requires that you to login first so that it can perform its user-based recommendation based on your profile of likes and dislikes of certain sites.<\/p>\n

EuclidianDistanceSimilarity<\/strong><\/h3>\n

Now we need to select an item-based algorithm that fits our dataset. The EuclidianDistanceSimilarity<\/span> is one of Taste’s algorithms that is suitable for explicit ratings and will be used for our demonstration. Before we construct our recommender we introduce the euclidian distance similarity in more detail. The algorithm computes the euclidian distance between each item’s preference vector. The shorter the distance between these vectors, the greater the similarity. For instance, suppose we have users u1, u2 and u3 and item i1. Let’s say these preferences for these users are 2, 4 and 5 respectively. We now have a preference vector [2,4,5] for item i1. The euclidian distance between two of such vectors can now be computed and used as a measure of their similarity. The formula for computing the euclidian distance between two vectors i and j equals the root of the sum of squared differences between coordinates of a pair of vectors. See the formula below:
\n$$!d_{ij}=\\sqrt{\\sum\\limits_{k=1}^n \\left(x_{ik} – x_{jk}\\right)^2}$$<\/p>\n

The EuclidianDistanceSimilarity<\/span> calculates this similarity for each pair of items and then returns<\/p>\n

$$!\\frac{1}{1 + d_{ij}}$$<\/p>\n

which results in a value between 0 and 1. The EuclidianDistanceSimilarity<\/span> can also be weighted. If you pass in the Weighting.WEIGHTED<\/span> enum to the constructor of EuclidianDistanceSimilarity<\/span> then the algorithm will weight the values based on the number of users and the number of co-occurring preferences.<\/p>\n

Creating a web-based recommender<\/strong><\/h3>\n

Below is a list of components we need to create a small web-based recommendation engine, using Taste, Wicket and JPA\/Hibernate. I won’t cover all the details of building this webapp, just the main building blocks. You can download the code for this example here<\/a> and look at the specific details. We need the following components:<\/p>\n