Content uploaded by Wim Verhaegh

Author content

All content in this area was uploaded by Wim Verhaegh

Content may be subject to copyright.

Fast Generation of Optimal Music Playlists using Local Search

Steffen Pauws, Wim Verhaegh, Mark Vossen

Philips Research Europe

High Tech Campus 34

5656 AE Eindhoven

The Netherlands

steffen.pauws/wim.verhaegh@philips.com

Abstract

We present an algorithm for use in an interactive music sys-

tem that automatically generates music playlists that ﬁt the

music preferences given by a user. To this end, we introduce

a formal model, deﬁne the problem of automatic playlist

generation (APG) and indicate its NP-hardness. We use a

local search (LS) procedure based on simulated annealing

(SA) to solve the APG problem. In order to employ this LS

procedure, we introduce an optimization variant of the APG

problem, which includes the deﬁnition of penalty functions

and a neighborhood structure. To improve upon the per-

formance of the standard SA algorithm, we incorporated

three heuristics referred to as song domain reduction, par-

tial constraint voting, and two-level neighborhood structure.

In tests, LS performed better than a constraint satisfaction

(CS) solution in terms of run time, scalability and playlist

quality.

Keywords: local search, simulated annealing, music

playlist generation, music retrieval.

1. Introduction

To realize personalized assistance in music choice, we re-

search the automatic generation of music playlists by means

of mathematical programming and combinatorial optimiza-

tion. As a ﬁrst prerequisite, we need to be able to reason

about songs. Therefore, we think of songs as a list of at-

tributes that are deemed to be relevant for music choice. As

shown in Table 1, song attributes can be nominal such as

the song/album title or the performing artist, allowing only

reasoning in terms of equivalence and set membership (e.g.,

these two songs are by the same artist). Attributes can also

be numerical such as the duration and the tempo of the song;

numerical attributes allow the computation of a difference

between attribute values. Data extracted from musical au-

dio such as a chroma spectrum for key/chord information

or timbre features devised for audio similarity purposes can

Permission to make digital or hard copies of all or part of this work for

personal or classroom use is granted without fee provided that copies

are not made or distributed for proﬁt or commercial advantage and that

copies bear this notice and the full citation on the ﬁrst page.

c

°2006 University of Victoria

be represented as vectors of numericals. Other types of at-

tributes (e.g., categorical,ordinal) are also possible.

Table 1. Song attributes and types.

kattribute type example

1 song ID nominal 101

2 title nominal All Blues

3 artist nominal Miles Davis

4 album nominal Kind of Blue

5 genre nominal Jazz

6 duration numerical 696 (secs)

7 year numerical 1959

8 tempo numerical 137 (bpm)

9 chroma spectrum numericals

10 audio features numericals

Informally, a playlist is a sequence of the ‘right’ songs at

the ‘right’ positions that can be played back in one go. What

is ‘right’ in this respect depends on the prevailing purposes

of everyday music listening. In our work, we model these

desired playlist properties as formal constraints that are de-

ﬁned over the playlist positions in terms of song attributes.

We distinguish three types of constraints. A unary constraint

poses a restriction for a single playlist position (e.g, the ﬁrst

song should be a ‘jazz-song’). A binary constraint declares

a desired relation between songs at two different positions.

Order or similarity of songs at two positions are examples

(e.g., both songs should have the similar tempo/timbre). Fi-

nally, a global constraint is deﬁned on any number of po-

sitions. For instance, they can express restrictions on car-

dinality for the entire playlist (e.g., there should be at most

two different genres in a playlist) or group a set of unary

or binary constraints all together (e.g., all songs should be

‘jazz-songs’).

Since the algorithms will be used in an interactive mu-

sic system, demands on efﬁciency,scalability, and playlist

quality (i.e., optimality) are pressing. Time to compute a

playlist should run in a few seconds, since there is a user

waiting for the result. In some applications, we can afford

ourselves to present a partial (non-optimal) playlist, while

computing the rest of the playlist. The algorithms should

scale towards playlists of any length and music collections

of any size and any variety. The returned playlist should be

optimal and reﬂect the music preferences given by the user,

even if these preferences result into conﬂicting constraints

and no playlist exists that meets all preferences expressed.

After discussing related work, we present a formal model

and the computational difﬁculties of the automatic playlist

generation problem in Section 2. An optimization variant of

the problem will be introduced in Section 3, which allows us

to use a class of generic approximation algorithms known as

local search. We will explain the use of simulated annealing,

as a special case of local search, for our optimization prob-

lem in Section 4. A study of the problem structure provided

us heuristics to improve simulated annealing for our prob-

lem. In Section 5, we show the evaluation of the algorithm

in a comparison test.

1.1. Related work

Playlist generation is an active ﬁeld within MIR. Here, we

only review approaches that use problem formulations sim-

ilar to ours.

Alghoniemy and Tewﬁk [1] present a network ﬂow ap-

proach to playlist generation and a branch and bound algo-

rithm to solve it as a binary linear program. Unfortunately,

branch and bound is an exponential algorithm in the worst

case.

Pachet, Roy and Cazaly [2] use a constraint satisfaction

formulation in which desired properties of the playlist are

declared by constraints to be met. Aucouturier and Pa-

chet [3] later re-formulate the problem to allow the use of

approximating algorithms based on local search to scale the

approach towards very large music collections. Costs are

associated with playlists: the more constraints are violated,

the higher the cost. The use of this solution method is also

the subject of this paper. A more detailed exposition of the

method and its evaluation can be found elsewhere[4].

2. A formal model

Formally, a song is given by a vector s= (v1, . . . , vK)

of attribute values, denoting that the k-th attribute of song

shas value vk∈Dk. For an example of attributes, see

Table 1. Next, a music collection is given by a set M=

{s1, . . . , sm}of msongs.

Aplaylist is formally deﬁned by a vector p=

(p1, . . . , pn)of length n, where pi∈Mdenotes the song

at the i-th position, for all i= 1, . . . , n. Each song piis

again a vector of length K, so we can denote attribute kof

song piby pik. Although the length nis not speciﬁed be-

forehand, we assume that a lower bound nmin and an upper

bound nmax are given.

A playlist has to meet a set of declared unary, binary and

global constraints. A unary constraint restricts the choice

of songs for one speciﬁc position. In its general form, it is

given by a triple (i, k, V ), for a position i∈ {1, . . . , nmin },

attribute k∈ {1, . . . , K}, and value set V⊆Dk, and it

implies that pik ∈Vhas to hold. For instance, to specify

that the ﬁrst song of the playlist should be of genre Rock or

Jazz, we choose i= 1,k= 5, and V={Rock,Jazz}. Note

that we do not allow i > nmin, as the resulting playlist may

not be long enough to have such a position.1

To enable a more efﬁcient speciﬁcation of unary con-

straints, we introduce the following three speciﬁc forms.

•In an exclude-unary constraint, we specify a set W⊆

Dkof forbidden attribute values, meaning that V=

Dk\W.

•In a range-unary constraint, the set of desired values

Vis given by an interval [v, w], that is, V={x∈

Dk|v≤x≤w}. This constraint requires a (partial)

order on the attribute involved.

•In a similar-unary constraint, the set Vis given indi-

rectly by V={x∈Dk|l≤f(v, x)≤u}, using

a similarity function f:Dk×Dk→[0,1], attribute

value v∈Dk, and bounds l, u ∈[0,1] on the desired

similarity.

Abinary constraint enforces a relation between songs

at two speciﬁc playlist positions. In its general form, it

is given by a four-tuple (i, j, k, d), for positions i, j ∈

{1, . . . , nmin}, attribute k∈ {1, . . . , K }, and function d:

Dk→2Dk, and it implies that pik ∈d(pjk )has to hold.

The function dis generally not given explicitly, but implic-

itly as in the following ﬁve speciﬁc forms of binary con-

straints.

•In an equal-binary constraint, the function dis given

by d(v) = {v}for all v∈Dk. This implies that pik =

pjk has to hold. For an inequal-binary constraint, we

take the complement given by d(v) = Dk\ {v}.

•In a smaller-equal-binary constraint, dis given by

d(v) = {x∈Dk|x≤v}, implying that pik ≤pjk

has to hold. Note that this constraint again requires

a (partial) order on the attribute. A greater-equal-

binary constraint is quite similar in its deﬁnition.

•Finally, in a similar-binary constraint, the function d

is given by d(v) = {x∈Dk|l≤f(x, v)≤u},

again using a similarity function f:Dk×Dk→

[0,1], and bounds l, u ∈[0,1] on the desired similar-

ity. So, this constraint implies l≤f(pik, pj k)≤u.

Global constraints pose restrictions on songs at a num-

ber of positions. The set of positions is denoted by

an interval [i, j], with i∈ {1, . . . , nmin}and j∈

{1, . . . , nmin, . . . , nmax }, which is formally deﬁned as the

set {l∈N|i≤l≤j∧l≤n}. Note that if j=nmax, then

this set depends on the length nof the playlist, and contains

at least all positions from nmin onwards in the tail of the

playlist.

1Or, conversely, if one wants to restrict the song on a certain position i,

one has to choose nmin ≥i.

There is no general form of a global constraint, except

that it always contains an interval [i, j]as described above,

and an attribute k∈ {1, . . . , K}on which it applies. Some

of the global constraints that we consider are deﬁned here-

under.

•Acardinality-global constraint is given by a ﬁve-tuple

(i, j, k, a, b), where apart from the interval [i, j]and

attribute ka lower bound aand upper bound bare

given on the number of different attribute values that

are allowed. More speciﬁcally, this constraint implies

that a≤ |{plk |l∈[i, j]}| ≤ bhas to hold.

•Acount-global constraint is given by a six-tuple

(i, j, k, V, a, b), with V⊆Dkand a, b ∈N, imply-

ing that a≤ |{l∈[i, j]|plk ∈V}| ≤ bhas to hold.

In other words, the number of songs in the interval

with an attribute value from Vshould be between a

and b.

•Asum-global constraint is given by a ﬁve-tuple

(i, j, k, a, b), with bounds a, b ∈R, and it denotes

that a≤Pl∈[i,j]plk ≤b. Note that it is only deﬁned

for numerical attributes.

In addition, we use global constraints that imply a unary

constraint on each position in an interval (i.e., each-global),

that poses a binary constraint on each two successive posi-

tions in an interval (i.e., chain-global), and that poses a bi-

nary constraint on every pair of positions in an interval (i.e.,

pairs-global).

Having everything in place now, we can give a formal

deﬁnition of the playlist generation problem, as follows.

Deﬁnition 1. (Automatic playlist generation problem

(APG)) Given a music collection M, a set of constraints

C, and length bounds nmin and nmax, ﬁnd a playlist pof

n∈ {nmin, . . . , nmax }songs from Msuch that psatisﬁes

all constraints in C.

Without going into details, we indicate that APG is NP-

hard. This is caused by aspects corresponding to four dif-

ferent NP-complete problems [5]. For instance, ﬁnding a

playlist in which each two consecutive songs are similar is

comparable to the Hamiltonian path problem. Next, ﬁnd-

ing a playlist in which for each attribute the occurring val-

ues are different corresponds to the 3-dimensional matching

problem. Finding a playlist with a total duration of a cer-

tain length corresponds to the subset sum problem. Finally,

ﬁnding a playlist in which each two songs are sufﬁciently

different is comparable to the independent set problem.

3. An optimization variant

As APG is NP-hard due to several reasons, we opt for a

generic approximation method. To this end, we convert

APG into an optimization variant APG-O by introducing a

non-negative penalty function that represents the amount of

violation of the constraints. Then, instead of searching for a

playlist that meets all constraints, we search for a playlist

that minimizes the penalty by a local search method. If

the penalty is zero, all constraints are met. Introducing a

penalty also overcomes the issue of over-constrained prob-

lem instances. In that case, no solution exists that meets all

constraints, but a playlist is generated that meets the con-

straints as well as possible.

The penalty function for a playlist is as follows. First,

we deﬁne for each constraint a penalty function that returns

a value from [0,1]. Next, the penalty of a playlist is given

by a weighed average of each of the constraint penalties.

The weights can be used to give more importance to one

constraint over the other. In case of an over-constrained in-

stance, this allows to trade-off different constraints.

For the penalty function deﬁnitions, we use a special nor-

malized difference function, ª, between attribute values.

•For a nominal attribute k, we determine (in)equality

between values, that is, for each two values a, b ∈Dk,

aªb= 0, if a=b, and aªb= 1, otherwise.

•For a numerical attribute k, we use the difference as

deﬁned by aªb=|a−b|

max Dk−min Dk.

Also for other types of attributes, a suitable difference func-

tion can be deﬁned.

Now, we can deﬁne the constraint penalties. For a unary

constraint (i, k, V ), we deﬁne the penalty as the minimum

difference to any element from V, that is, as min{pik ª

v|v∈V}. We however make an exception for two of the

three speciﬁc forms.

•For an exclude-unary constraint, the set Vis indicated

by its complement W=Dk\V, with Wtypically

very small. To prevent very small penalty values due

to normalization, we deﬁne the penalty for this con-

straint as 0if pik 6∈ Wand 1otherwise.

•For a similar-unary constraint, the requirement is that

f(v, pik )should lie in the interval [l, u]. Hence, we

deﬁne the penalty to be equal to the distance to this

interval, that is, the penalty is given by min{|x−

f(v, pik )| | x∈[l, u]}. This is comparable to the

general deﬁnition of unary-constraint penalties, ex-

cept that we deﬁned it on the co-domain of f, instead

of on attribute values directly.

For a binary constraint (i, j, k, d), the requirement is that

pik ∈d(pjk ). The corresponding penalty is therefore de-

ﬁned as min{pik ªv|v∈d(pjk )}, comparable to unary

constraints. Again, we make the following two exceptions

to this deﬁnition.

•For an inequal-binary constraint, we deﬁne a penalty

of 0if pik 6=pjk and 1otherwise.

•For a similar-binary constraint, we again use the

similarity function fand bounds l, u in the deﬁni-

tion of the penalty, resulting in a penalty min{|x−

f(pik, pj k)| | x∈[l, u]}.

The penalties for global constraints are deﬁned as fol-

lows.

•For a cardinality-global constraint (i, j, k, a, b), the

number γ=|{plk |l∈[i, j]}of different attribute

values is required to lie between aand b, hence we de-

ﬁne the penalty by 1

δ·min{|x−γ| | x∈ {a, . . . , b}},

where δis given by max{a, |[i, j]| − b}for normal-

ization.

•For a count-global constraint (i, j, k, V, a, b), the

number of songs µ=|{l∈[i, j]|plk ∈V}with

an attribute value from Vshould lie between aand b,

so we deﬁne the penalty by 1

δ·min{|x−µ| | x∈

{a, . . . , b}}, with again δ= max{a, |[i, j]| − b}.

•For a sum-global constraint (i, j, k, a, b), where the

sum σ=Pl∈[i,j]plk should lie in [a, b], the penalty

is given by 1

δ0·min{|x−σ| | x∈[a, b]}. As the mini-

mum possible sum equals v=|[i, j]|min Dkand the

maximum possible sum equals w=|[i, j]|max Dk,

we choose the normalization constant δ0= max{a−

v, w −b}.

In addition, the penalties for the each-global,chain-

global and pairs-global are deﬁned by the normalized sum

of the penalties of their constituent unary or binary con-

straints.

4. Local search

The deﬁnition of the optimization variant APG-O allows us

to solve it with a generic approximation method such as lo-

cal search (LS) [6]. The key feature of local search is that

it searches the solution space by iteratively stepping from

one solution to a neighboring solution, and comparing their

quality. A neighborhood structure deﬁnes which solutions

are neighbors to a given solution, which are usually obtained

by making small alterations to the given solution. For APG-

O, solutions are given by playlists, and its neighborhood

structure is given in Section 4.2, consisting of replacements,

insertions, deletions, and swaps of songs. The cost function

is obviously given by the total weighed penalty of a playlist,

which we denote by f(p).

A solution is called locally optimal if there is no neigh-

boring solution with better cost. A solution is called globally

optimal if there is no solution in the whole solution space

with better cost. The objective of APG-O is to ﬁnd such a

global optimum, that is, a playlist with minimal penalty.

4.1. Simulated annealing

Basic LS algorithms like iterative (ﬁrst and best) improve-

ment were found not to be well equipped to solve our prob-

lem as they fell into local optima. Therefore, we consider

simulated annealing (SA), which incorporates a mechanism

to escape from local optima without a need for restarting [7].

In contrast to the basic LS algorithms, SA replaces the

deterministic (strict improving) acceptance criterion by a

stochastic criterion. More speciﬁcally, a control variable t

is introduced, and the chance of accepting a neighboring so-

lution p0to a given solution pis deﬁned by the acceptance

probability

Pr(p0|p) = (1if f(p0)≤f(p), and

exp ³f(p)−f(p0)

t´otherwise.

As we can see, the chance of accepting a deteriorating solu-

tion depends on the amount of deterioration, as well as the

control parameter t. For each value of t, sequences of so-

lutions are generated and evaluated, after which the control

variable is lowered by a decrement function. As a result, the

chance of accepting deteriorating solutions decreases dur-

ing the course of the algorithms. For further explanation of

SA, we make a forward reference to Figure 1 for our ﬁnal

algorithm.

SA algorithms make use of a so-called cooling schedule,

which consists of the sequence length of solutions Lh, the

initial value of the control parameter t0, the decrement func-

tion used for decreasing t, and a stop criterion. We use a ge-

ometric cooling schedule that has been successfully applied

to many problems described in literature. For APG-O, this

results in a choice of Lh= 10,t0= 1, decrement function

th+1 = 0.9·th, and stop criterion (f(p)< ² || h > H), that

is, we stop if all constraints are ‘sufﬁciently’ satisﬁed or we

did a pre-deﬁned number of iterations.

4.2. Neighborhood deﬁnition

For the neighborhood, we deﬁned the following four types

of moves.

Areplace move chooses a playlist position and a new

song from the music collection and replaces the song that is

at that position by the new song.

An insert move chooses a position in the playlist (if n <

nmax) and a new song from the music collection and inserts

that song into the playlist at the chosen position.

Adelete move chooses a position in the playlist (if n >

nmin) and removes the song at that position.

Finally, a swap move chooses two positions in the playlist

and swaps the songs that appear at these positions.

Each of the above four types of moves deﬁnes a neigh-

borhood. The complete neighborhood is given by the union

of these four neighborhoods. To balance the selection of the

four individual neighborhoods for generating a new solu-

tion in our SA algorithm, we introduce probability weights

wreplace,winsert , and wdelete, which determine the proba-

bility of performing a particular type of move. In tests [4],

we found 1/3to be a good performing value for all weights

for a collection of 2,248 songs. Swap moves are treated in a

separate neighborhood (see Section 4.3.2).

As the moves described above make small modiﬁcations

to a playlist, the changes in penalty function can be calcu-

lated incrementally, and thus more efﬁciently.

4.3. Heuristic improvements

In order to increase the performance of SA, we propose

three heuristic improvements based on the various types of

constraints in APG-O: song domain reduction, a two-level

neighborhood, and partial constraint voting.

4.3.1. Song domain reduction

Song domain reduction resembles a form of constraint prop-

agation to guarantee node consistency for unary constraints

used in constraint satisfaction methods [8]. To this end, we

denote a song domain Miof a position ias the subset of the

music collection, Mi⊆M, that deﬁnes the possible songs

that are allowed at that position; for a playlist p, it should

hold that pi∈Mi. By reducing the song domains Mi, we

can in this way trim the search space for our LS. If a posi-

tion is not over-constrained, the reduction is established by

removing all songs from a given song domain that do not

meet all unary constraints that are declared for the position

under consideration. We have developed different reduction

mechanisms for all four individual neighborhood structures.

4.3.2. Two-level neighborhood structure

The penalties of global constraints such as cardinality-

global and sum-global constraints are not affected by swap

moves; they do not depend on song order. In contrast, most

unary and binary constraints and their combinations into

global constraints do depend on song order.

Based on this observation, we introduce a two-level

neighborhood, splitting the search into two procedures, that

are applied alternatingly. The ﬁrst procedure consists of a

sequence of βreplace, insert, and delete moves, for meet-

ing constraints that do not depend on song order. Next, a

sequence of swap moves is applied to put the songs in the

right order. For the latter, we employ a simple procedure,

called non-deteriorating reordering (NDR), which applies

iterative improvement with a maximum of γswap moves.

In tests [4], we found 100 to be a good performing value for

both βand γfor a collection of 2,248 songs.

4.3.3. Partial constraint voting

Simply applying random moves at randomly chosen playlist

positions leads to an inadequate coverage of the restrictions

as posed by some global constraints, notably the cardinality-

global and the count-global constraints. These constraints

need speciﬁc types of songs at speciﬁc positions. To this

end, we apply a partial constraint voting mechanism in

which constraints vote for or against a playlist position and a

song in a move. Every constraint can cast a positive vote for

a position with a song in a given solution, if it contributes

to its violation. On the other hand, a constraint can cast a

negative vote for a position with a song, it it helps in its

satisfaction. The votes from all constraints are tallied, and

a playlist position is chosen biased by these votes. So, a

position with many positive votes and a few negative votes

is more likely to be chosen than a position with fewer pos-

itive votes and more negative votes. If the replace or the

insert neighborhood was selected, we also have to vote for a

speciﬁc song to be added to the playlist. For efﬁciency rea-

sons, only the above-mentioned global constraints can vote

for songs. Again, the song votes are tallied and one song is

chosen, biased by the collected votes.

Though this voting mechanism is effective in direct-

ing constraint satisfaction, it is computationally intensive

in comparison to random selection of positions and songs.

Therefore, we limit its use to a fraction δof the reselect

moves. In tests [4], we found δ= 0.3to be a good perform-

ing value for a collection of 2,248 songs.

4.3.4. Final algorithm

The adapted SA algorithm is depicted in Figure 1.

INITIALIZE p,t0,L0;

h:= 0;

r:= 0;

repeat

for l:= 1 to Lhdo

begin

if r < β then

begin

if δ > random[0,1) then

GENERATE RANDOM p0∈Nreselect (p)

else GENERATE p0∈Nreselect (p)BY VOTING;

if f(p0)≤f(p)or exp(f(p)−f(p0)

t)>random[0,1)

then p:= p0;

r:= r+ 1

end

else begin

p:= NDR(p, γ);

r:= 0

end

end;

h:= h+ 1;

CALCULATE LENGTH Lh;

CALCULATE CONTROL th

until STOP CRITERION

Figure 1. The resulting algorithm for APG-O.

5. Evaluation

In performance tests, the algorithm was shown to be an im-

provement over a previously designed constraint satisfaction

(CS) algorithm on efﬁciency, scalability and playlist quality

(optimality). We used constraint sets that were inspired by

10 14 18 22 26 30

0.1

1

10

100

1000

CS

LS

playlist length

mean run time (secs)

02468

x 104

0

5

10

15

20

25

30

LS

CS

music collection size 10 20

0

2.5

5

7.5

10

LS

CS

playlist length

mean rating score

Figure 2. (a) Mean run time over 10 runs as a function of playlist length for LS (local search) and CS (constraint satisfaction) using

a set of 15 global constraints. (b) Mean run time over 10 runs as a function of music collection size for LS and CS using a set of 15

global constraints. (c) Mean rating score across LS and CS and different playlist lengths. Cross-bars represent standard errors of the

mean.

previous user studies [9] and music collections ranging from

2,248 songs to 71,194 songs. In Figure 2 (a), we see that LS

runs shorter and less erratic in run time than CS does for a

set of 15 global constraints for different playlist lengths and

a collection of 2,248 songs. Ten runs of the test were per-

formed to arrive at a mean run time. The typical run time

of the algorithm is about 2 seconds on a PC platform for

playlists of at most 14 songs, a collection of about 2,000

songs, and various constraint sets. In Figure 2 (b), we see

a linear increase on run time for larger music collections

for LS generating playlists of 10 songs using the same set

of constraints. Its run time on a large music collection is

too high for particular interactive applications. CS did not

generate playlists for large music collections due to memory

insufﬁency.

In a user evaluation, eighteen participants (22-41 years;

13 men, 4 women) were asked to rate on a scale of 0to 10

(extremely bad-good) 48 playlists in total of varying lengths

that were generated either by LS or CS using various con-

straint sets. As shown in Figure 2 (c), playlists generated by

LS were rated signiﬁcantly higher than playlists generated

by CS (mean rating score for LS playlists: 7.7; mean rating

score for CS playlists: 6.5; F(1,17) = 56.6, p < 0.001).

Also, we see that longer CS playlists were rated signiﬁcantly

lower than smaller CS playlists, whereas this is not true for

LS playlists (F(1,17) = 7.6, p < 0.05).

For a detailed description of the evaluation, we refer

to [4].

6. Conclusion

The algorithm has already been embedded in interactive mu-

sic prototype systems and services designed for consumer

electronic devices [9]. These systems open up completely

new methods for users to experience music by the art of

re-combining songs in various ways. Playlist generation is

also useful for automatic DJ-ing applications that require

that songs are ﬁrst ordered on meter, tempo and key before

they are mixed one after the other. Online music sales ap-

plications can be easily augmented with a service to auto-

matically compile and download a personal album. Music

streaming and broadcasting can excel using on-the-ﬂy gen-

eration of music programs allowing truly personal and inter-

active (Internet) radio and podcasting.

References

[1] M. Alghoniemy and A.H. Tewﬁk, “A Network Flow Model

for Playlist Generation”, In: Proceedings of the IEEE

International Conference on Multimedia and Expo 2001

(ICME2001), August 22 - 25, 2001, Tokyo, Japan.

[2] F. Pachet, P. Roy and D. Cazaly, “A Combinatorial Approach

to Content-based Music Selection”, IEEE Multimedia, 7, 1,

2000, 44-51.

[3] J.-J. Aucouturier and F. Pachet, “Scaling up Music Playlist

Generation”, In: Proceedings of the IEEE International Con-

ference on Multimedia and Expo 2002 (ICME2002), August

26 - 29, 2002, Lausanne, Switzerland.

[4] S. Pauws, W. Verhaegh and M. Vossen, “Playlist Generation

by Adapted Simulated Annealing”, In: Vasilakos, A. (Ed.),

Information Science: Special Issue on Ambient Intelligence,

2006.

[5] M.R. Garey and D.S. Johnson, Computers and Intractabil-

ity: A Guide to the Theory of NP-Completeness, 1979, W.H.

Freeman and Company, New York.

[6] E.H.L. Aarts and J.K. Lenstra, Local Search in Combinato-

rial Optimization, 1997, Wiley.

[7] S. Kirkpatrick, C.D. Gelatt and M.P. Vecchi, “Optimization

by Simulated Annealing”, Science, 220, 4598, 1983, 671–

680.

[8] E.P.K. Tsang, Foundations of Constraint Satisfaction, Aca-

demic Press, 1993.

[9] S. Pauws and S. van de Wijdeven. “User Evaluation of a

New Interactive Playlist Generation Concept.” In: Proc.

Sixth International Conference on Music Information Re-

trieval (ISMIR2005), Reiss, J.D. & G.A. Wiggins (Eds.). 11-

15 September 2005, 638–643.