1. A FAIR ASSIGNMENT FOR MULTIPLE PREFERENCE QUERIES
Rohit Anurag, Rahul Nayak

2. Scenario
Some users want to select objects with specific features, based on their preferences
These requests are performed as database queries
Queries express users’ preferences by different weights on the attributes of the searched objects
These are the so-called Preference Queries

3. A FAIR ASSIGNMENT PROBLEM
Scenario
The result of a preference query is the object in the database with the highest aggregate score
If multiple preference queries are issued simultaneously, an object may be the best solution for many of them:
Who will be coupled to the object?
Which results will receive other users?
A FAIR ASSIGNMENT PROBLEM

4. Scenario - Example
Internship assignment, based on student’s preferences in terms of:
nature of the job
Salary
office location
other features…
For a single student the system returns a set of top-k results with respect of his/her preference function
An available internship position could be the top-1 choice of many interested students. It can only be assigned to one of them

5. Scenario - Example
Internship assignment, based on student’s preferences in terms of:
nature of the job
salary
office location
other features…
Users’ preference functions
f1=0.8X+0.2Y
f2=0.5X+0.5Y
Positions’ attributes
a=(0.5,0.6)
b=(0.2,0.7)
c=(0.8,0.2)
d=(0.4,0.4)
Best point
(standing) Y f2 b f1 a d c
(salary) X

6. Related Algorithms
1-1 assignment problem is related to three types of search:
Spatial Assignment problem (model: SMP)
Chain Algorithm
Skyline Queries
Branch-and-Bound Skyline Algorithm
Top-k Search
Threshold Algorithm

7. Spatial Assignment Problem – Chain Algorithm
Its goal is to find a stable pair
Its preference function is based on Euclidean distance
a prefers b’ to b if dist(a,b’) < dist(a,b)
A pair (a,b) is stable if and only if a’s closest object is b and b’s closest object is a, where a and b are among the unassigned (remaining) objects in A and B
Chain algorithm:
pick an object from A (randomly) or Q;
find the NN (Nearest Neighbour) of a∈ A (aB∈ B);
find the NN a’ ∈ A of aB∈ B;
if a ≠ a’, aBis pushed into a queue Q; otherwise pair (a,aB) is output as the result pair and a, aB are removed from A and B.

8. Skyline Queries – BBS Algorithm
A different approach exploits the set’s skyline concept
The skyline of O consists of all points o ∈ O that are not dominated by any other point in O.
It’s faster if the objects are indexed by an R-Tree
BBS algorithm:
Compute the skyline of O by accessing the minimum number of R- tree nodes it is I/O optimal
Access the node of the tree in ascending distance order from the sky point
Sky point is the (imaginary) most preferable object possible.
Once a data object is found, it is added to the skyline and all R-tree nodes/subtrees dominated by it are pruned.

9. BBS Algorithm–Example
sky M1 M2 M3 m1 m2 m3 m4 m5 m6 m7 a m2 M1 M3 m7 c d e
g h
a c d
e i
j l
k m
b f
... m3 m6 b g m1 f h i j
INN Heap = {e, i, m1, m2, M2,M3}
INN Heap = {a}
INN Heap = {m1, m2, m3, M2,M3}
INN Heap = {M1, M2,M3}
INN Heap = {m2} m4 l k
Osky = {e, a}
Osky = {e} m5 M2 m

10. Top-k search – Threshold Algorithm
O is a collection of n objects, an object o has D attributes
D S1, S2, …, SD sorted lists, one for each attribute, ordered by the atomic scores
A top-k query, based on an aggregate function f, retrieves a k-subset Otopk of O (k<n), such that f(o) ≥ f(o’), ∀o ∈ Otopk, o’ ∈ (O−Otopk)
The most used algorithm for top-k queries is Threshold Algorithm (TA)
pops objects form the sorted lists in round-robin manner
for each object o, f(o) is computed
The set of k objects with the highest score is maintained
the search terminates when the k-th score is greater than or equal to threshold T

11. Problem Statement
A set of user preference function F over a set of multidimensional objects O.
The score f(o) of an object o is:
Our goal is to find stable 1-1 matching between F and O
A function-object pair (f, o) in F × O is stable, if there is no function f’ ∈ F, f’ ≠ f, f’(o) > f(o) and there is no object o’ ∈ O, o’ ≠ o, f(o’) > f(o), where F and O are the sets of the unassigned (remaining) functions and objects.

12. Algorithms – Brute Force Search
Assumption: F kept in memory, O indexed by an R-tree (Ro) on the disk
Progressive technique
Issue top-1 queries against O, one for every function in F (|F| pairs)
The pair (f,o) with the highest f(o) value should be stable
o is the top-1 preference of f
f’(o) cannot be greater than f(o) for any function f’ ≠ f
After the pair (f,o) is added to the query result
o is removed from Ro
If o was the top-1 object for another function f’ ≠ f, top-1 search must be re-applied for f’
Improvements: maintaining the search heap for each top-1 query, the search can resume
Drawback: large amount of memory!

13. Algorithms – Skyline-Based Search
Assumption: if F contains only monotone function, than the top-1 objects should be in Osky
Stable function-object pairs between Osky and F are found and output
Osky is computed and maintained
SB(set F, R-tree Ro)
Osky := ∅
while |F| > 0 do
First we compute the skyline Osky
Osky := ComputeSkyline(RO)
Then while there are unassigned functions the pair (f,o) with the highest f(o) score is found
UpdateSkyline(Osky, o, RO)
(f,o):=BestPair(F, Osky)
Output (f,o)
Finally, f and o are removed from F and O, and Oskyis updated
F := F-f; O := O-o; Osky:= Osky-o

14. Algorithms – Skyline-Based Search (Example)
Ricordati di dire BAUUUUUUUUUUUUUUUUUUUU

15. Implementation – UpdateSkyline (Example)
To minimize the tree traversal cost during skyline maintenance, the dominated objects by o are pruned and these entries are added to the pruned list o.plist
To minimize the required memory, each pruned object is kept in the plist of only one skyline object
Scand := ∅
algorithm UpdateSkyline(set Osky, object o,R-tree RO)
new Osky :=ResumeSkyline(Scand , Osky)
algorithm ResumeSkyline(set Scand, set Osky)
while S is not empty do
else ⊳ not dominated by any skyline object
else
Scand :={E|E ∈ o.plist, E ∉o’.plist, ∀o’ ∈ Osky } c b m1 M2
de-heap top entry E of Scand d a
if E is dominated by any o ∈ Oskythen
add E to o.plist M3
if E is non-leaf entry then
visit node N pointed by E
for all entries E’ ∈ N do
push E’ into Scand
Osky :=Osky ∪ E
Scand = {d}
Scand = {M3, a, b, d}
Scand = {M2, M3, a, b, d}
Scand = {c, M2, M3, a, b, d}
Scand = {m1, c, M2, M3}
Scand = {a, b, d}
Scand = {b, d}
Scand = {}
Osky = {a, b, c}
Osky = {c}
Osky = {a, c}
c.plist = {M2}
c.plist = {M2, M3}
b.plist = {d}

16. Algorithms – Skyline-Based Search (Optimization)
The numbers of loops required can be reduced if multiple stable
object-function pairs are output at each loop
SB(set F, R-tree RO)
Osky :=∅; Odel := ∅
while |F | > 0 do ⊳more unassigned functions
if Osky =∅ then
Osky :=ComputeSkyline(RO)
else
UpdateSkyline(Osky, Odel, RO)
Odel := ∅
Fbest :=∅
for all o ∈ Osky do
find function o.fbest∈F that maximizes f(o)
Fbest :=Fbest ∪ o.fbest
for all f ∈ Fbest do
find object f.obest∈Osky that maximizes f(o)
for all f∈Fbest do
if (f.obest).fbest=f then
F := F − f ; O := O − f.obest
Osky := Osky−f.obest; Odel := Odel∪f.obest
Fbest is the subset of F that includes the functions o.fbest that maximize f(o)
For each f∈Fbest, the object f.obest that maximizes f(o) is coupled with the function f
If (f.obest).fbest=f, then (f, f.obest) is stable and the function/object is removed from F/O and Osky
At least one pair is guaranteed to be output

17. Experiments – |F| and |O| Dependency
PAUSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

18. Experiments – Dimensionality D
PAUSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

19. Conclusions SB is proven to be:
I/O optimal by using an incremental skyline maintenance algorithm, which is proven to be I/O optimal
CPU optimal by accelerating the matching between functions and skyline objects and identifying multiple stable pairs in each iteration

20. THANK YOU FOR YOUR ATTENTION
Conclusions
THANK YOU FOR YOUR ATTENTION
Fine!!
Dedicated to Chip…. RIP