Exploiting Group Recommendation Functions for Flexible Preferences

Introduction

This paper target an issue about group recommendation system

Group recommendation system is a system that recommend set of items to the users that belong in a group (to make it clear, each person in the group receive the same recommendations)

This group recommendation is based on the individual preferences that were set by each user in the group

In the previous work, it stated that reaching consensus or agreement between group members is an important step in group recommendations

Also in the previous work, group recommendation system usually based on the user’s past preference

Background

In this paper, they want to focused in a specific scenario where users are provided with a way to update their preferences during recommendation time

This flexibility give the users to choose items they would like or not to see during recommendation time and the system take into account the newly provided preferences to update the recommendations

Using this scenario, they believe that this new feature is useful in a number of practical applications where users are likely to be in different mindset and do not want the system to solely based on their past reference

In this case they are using travelling scenario to cope with the problem

They realize that in such condition/scenario, users will much likely to update their preferences consciously in an effort to maximize their individual satisfaction

Proposal

They introduce a flexible feedback model in the form of a vector of preferences that any group member could provide at recommendation time

This model contain a feedback box that outputs a feedback vector for each group member such that her satisfaction is maximized in the generated recommendation

The feedback box will replace the preference vectors provided by the users by a potentially different feedback vector that is better suited for helping users enforce their new preferences

In addition, they also realize it can be disconcerting for existing users to experience drastic changes to recommendation due to users update

They introduce recommendation robustness to ensure that generated recommendations after preference updates overlap with the ones generated before

Scenario

In order to evaluate the usefulness of the proposed system, they evaluate using two kinds of measurement and group recommendation consensus function

The group recommendation consensus function is a function which is used to identify group’s agreement from several individual data

They use Aggregated Voting and Least Misery group function

To measure user satisfaction they use a simple form of Jaccard Index, Overlap Similarity to calculate the similarity between the user preference/feedback vector and the recommendation

They also use Hamming Distance measurement to calculate the dissimilarity (distance) between them.

Interaction Models

To elicit preference, user input Boolean vector data where value 1 corresponds to the items user prefers to consume and value 0 otherwise

After that feedback generation process take place to generate output through the feedback box

During this phase, the system through the feedback box computes for the user a suggested Boolean feedback vector

Data model

User Preference Vector : A preference vector under Boolean model defines a subset of items that a user would like to consume

User Feedback Vector : This vector is the generated feedback for each user that the recommendation function uses to recommend items to the group

Robustness : The robustness quantify the similarity between the current recommendation (after user update) and the previous recommendation using similarity measures

User Satisfaction : The inverse of distance, or proportional to the similarity between user preference and recommended item vector

Data Model

Aggregated Voting : The Aggregated Voting Consensus generates a set of items recommendation such that an overall aggregated user satisfaction is maximized

Least Misery : The Least Misery Consensus generates a set of item recommendation such that the minimum user satisfaction is maximized

Problem Definitions

Recommendation Generation : The recommendation generation task is executable whether the preferences of a user are updated

The input of recommendation generation is the latest feedback vector of all user in the group, and a budget (maximum number of items to be recommended)

The output of recommendation generation is vector with at most 1-bits

The goal is to find that optimizes user satisfaction based on the employed group consensus function

Problem Definitions

Feedback Generation : The feedback box is executed whenever a member updates her preferences

The input is the new preference of the user, the feedback vectors of other existing members, the current budget and the group recommendation function

The output is a Boolean feedback vector

Aggregating Voting Consensus(Overlap Similarity)

Overlap Similarity only considers the items for which user has expressed preference by setting the corresponding bit into 1

Under Aggregated Voting the recommendation task becomes determining a set of items that maximizes the sum of overlap similarity for all group members

In the Generating Recommendations Task, they use the algorithm R-AGS :

1. Given the feedback vectors of all users, R-AGS associate a score for each item index, this score of an item is defined as the number users who give preference 1 for those item

2. After this R-AGS determine top- most preferred items with the highest score

Aggregating Voting Consensus(Overlap Similarity)

In the Generating New Feedback Vector task, they realized that feedback box is not useful

They find that if the aggregated consensus function is used, and satisfaction measure is Overlap Similarity, the feedback(u) will always be subset of pref(u)

This make the feedback(u) will be at most as useful as pref(u)

Aggregating Voting Consensus(Hamming Distance)

Unlike overlap similarity, Hamming Distance is measured by considering both 0 and 1 preferences

In Generating Recommendation task, they use algorithm R-AGD The basic idea is to relax the integrality constraint and then solve it as a

centroid finding in geometric settings using Algorithm 1

After the C is obtained , they do deterministic rounding with C >= 0.5 the preference is set to 1, otherwise 0

For choosing the items, they arbitrarily choose from those who held value of 1

Aggregating Voting Consensus(Hamming Distance)

In Generating New Feedback Vector task, they use algorithm FB-AGD :

Let the user who has a new preference

Then the computation is formulated as a quadratic optimization problem, such that the objective function maximizes user satisfaction (by minimizing Hamming Distance between and the generated recommendation)

After that, it performs deterministic rounding and obtain a Boolean feedback

Least Misery Consensus(Overlap Similarity)

Using Least Misery Consensus Function, the goal is how to compute recommendation so that the minimum satisfaction of the group is maxed

In the Generating Recommendation Task, they use Approximation Algorithm R-LMS

This algorithm initialize each set item in recommendation vector to 0 in the beginning

After that it operates in iteration where a single item is selected and the value is changed to 1 in each iteration

The selected item is corresponding to one rule : at each iteration, it selects an item that is not yet set in the recommendation vector from that user who has the current Least Misery value ( least overlap with the recommendation

The iteration terminates when exactly bits of recommendation vector are set to 1 in this process

Least Misery Consensus(Overlap Similarity)

In Generating New Feedback Vector task, they use Optimal Algorithm FB-LMS

Let assume there are users in a group where has a preference update

Let be the set of items that are set to 1 in the generated recommendation for that group without considering

Let be the items that are present in ’s latest preference

This algorithm generates which only sets items to 1

Least Misery Consensus(Hamming Distance)

In Generating Recommendations Task, they are interested to compute recommendation such that the maximum Hamming Distance between the generated recommendation and individual feedback vector/pref vector is minimized

They use algorithm R-LMD

This algorithm designed as an optimization problem where the quadratic equation is solved by a general purpose solver to obtain recommendation vector where each value is fractional value between 0 and 1

After the optimization process, they perform deterministic rounding

Least Misery Consensus(Hamming Distance)

In Generating New Feedback Vector Task, they use algorithm FB-LMD

The task of this algorithm is to generate that maximizes user satisfaction by minimizing Hamming Distance

This algorithm is also using quadratic optimization

Pretty similar process with generating recommendation task, deterministic rounding is performed after the optimization process

Recommendation Robustness

Robustness is considered as a soft constraint that could further be tuned

The primary idea is to add the previously generated recommendation vector as a new feedback vector (as a pseudo-user) to the recommendation function

They believe that this should achieve higher degree of robustness

Experiments

Using real world data sets from

Lonely Planet

Flickr

MovieLens

Implemented in C++ using IBM CPLEX for formulations

All experiments conducted on AMD machine quad-core 2.0 GHz CPUS, 8GB Memory, and 1TB HDD, running Ubuntu 12.10

Performance Experiments(Recommendation Generation)

Varying Budget : Study the running time by varying number of recommended items at each iteration

Performance Experiments(Recommendation Generation)

Varying Group Size : Study the running time by varying number of group size at each iteration

Performance Experiments(Recommendation Generation)

Varying Total Number of Items : Study the running time by varying number of items at each iteration

Performance Experiments(Feedback Box)

Varying Budget : Almost unchanged for all

Varying Group Size :

Performance Experiments(Feedback Box)

Varying Total Number of Items :

Quality Experiments

User Satisfaction with feedback box : The objective is to verify if user satisfaction is improved in the presence of a feedback box

The usefulness of a feedback box is evaluated by varying pairwise similarity between users in a group

Quality Experiments

Group Size Vs User Satisfaction

Recommendation Robustness : Effectiveness and Runtime Recommendation robustness is

a set as a soft constraint which could further be tuned

For example to achieve a robustness weight of 20% after the preference update of a user with k=20, m=125, n=75 , the previous recommendation need to be added 15 times

Conclusion

They motivate the need for flexible user preferences in group recommendation

They develop a feedback box that computes for each user with evolving preferences the best feedback to provide to maximize user satisfaction in the generated recommendation

They also present robustness to counterbalance the effect of feedback box and ensure group satisfaction

They present a rigorous theoretical and empirical study that corroborates the usefulness of this box