{'fraction_non_alphanumeric': 0.030006043248640268, 'fraction_numerical': 0.006857773457000972, 'mean_word_length': 4.173304336006525, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 65, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Context-Based Prediction of App Usage

There are around a hundred installed apps on an average smartphone. The high number of apps and the limited number of app icons that can be displayed on the device's screen requires a new paradigm to address their visibility to the user. In this paper we propose a new online algorithm for dynamically predicting a set of apps that the user is likely to use. The algorithm runs on the user's device and constantly learns the user's habits at a given time, location, and device state. It is designed to actively help the user to navigate to the desired app as well as to provide a personalized feeling, and hence is aimed at maximizing the AUC. We show both theoretically and empirically that the algorithm maximizes the AUC, and yields good results on a set of 1,000 devices.


Introduction
Smartphones are one of the most widely used devices nowadays. It is estimated that today about half the adult population owns a smartphone. The average American actively uses a smartphone more than two hours every day, and nearly 80% of smartphone-owners check messages, news or other services within 15 minutes of getting up.
One of the things that made smartphones ubiquitous is their ability to execute countless apps. Those apps take the advantage of the device's high computation power, constant internet connection, and features like location services, and use them to handle various tasks. Google Play store offers 1.5 million apps for Android users. On the average, there are 97 installed apps on typical smartphone according to the logs of EverythingMe, and similarly, there are 96 installed apps according to Yahoo Aviate's logs [1]. The high number of installed apps and the limited number of app icons that can be displayed on the device's screen, requires a new paradigm to address their visibility to the user.
In this paper we propose a new algorithm for dynamically predicting a set of apps that the user is likely to use. A set of app icons (usually four) are presented on a special dock, called Prediction Bar, and dynamically change according to the user's habits at a given time, location, and device state (headphone connected, bluetooth active, and so on). For example, a user often uses the app Evernote to take notes during the morning at her office, but never at home or during the weekend. Every Saturday morning she goes to the farmers market and then uses BestParking to help her find a nearby parking place. Every now and then she uses Facebook. The time, location and the device state are all considered as the context of the user's device. The goal of the algorithm is, given the context information, to actively help the user navigate to the desired app as well as to provide a personalized feeling.
The algorithm proposed here is based on learning the user's preferences in an online fashion. The algorithm keeps a weight vector (a set of parameters) for each of the installed apps. The user's contextual information is represented as a vector of real numbers called feature primitive that is mapped to a high dimensional abstract space, to have a more meaningful representation for the learning process. The projection of the mapped feature primitives onto any of the app's weight vector is the score associated with that app. At a given context the algorithm selects the set of apps that attain the highest score, and presents them to the user as icons in the Prediction Bar. Then the user clicks on one of the apps, either in the Prediction Bar, or elsewhere. If the clicked app is not presented in the Prediction Bar, or is in the Prediction Bar, but with a low score, then the algorithm updates the weight vector associated with the clicked app. The algorithm also updates all the weight vectors of the apps that where mistakenly predicted with a higher score than the clicked app.
One way to assess the performance of the algorithm is by checking the precision of the prediction, that is, the number of times the user clicks on the apps displayed in the Prediction Bar relative to the number of times she clicks on apps displayed anywhere (including the Prediction Bar). While this might sound a very reasonable measure of performance, it seems that this evaluation metric tends to predict the most frequent apps and ignores rarely used apps. It prefers, for example, the prediction of frequently used apps, like Facebook, at any time and location, over the prediction of apps like GateGuru, which the user uses only at airports, or BestParking, which the user uses every Saturday morning when she searches for a parking spot. An empirical study conducted by EverythingMe showed that the naive paradigm that constantly presents the most frequent apps in the Prediction Bar, attains the highest precision (see Section 4). This, of course, does not serve our goals of helping the user navigate to the desired app or of providing a personalized feeling.
As we shall see from the empirical analysis, we prefer to assess the quality of the prediction using a different metric, namely, the area under the receiver operating characteristic curve (AUC). This measure of performance tends to prefer predictions with a high true positive rate and a low false positive rate, which means that a mis-prediction of any app has the same cost -no matter how frequent the app is.
We propose an efficient online algorithm that is executed on the device. It is based on the Passive-Aggressive online algorithmic framework [3], adapted to maximize the AUC at each round. While there exists algorithms to maximize the AUC, such as [12,19], they are different from the algorithm proposed here in several aspects. Firstly, the algorithms [12,19] are batch algorithms. In the batch setting the input to the algorithm is a training set of labeled examples, and the output of the algorithm is a hypothesis that should perform well on an unseen data that drawn from the same distribution of the training set. In the online setting, which we are interested in this paper, the algorithm constantly adapts the hypothesis, and there is partition of the data into a training set or a test set. The online learning algorithms works in rounds, where at each round the algorithm get as an input a feature vector that represents the device context and has to predict the next apps the user will use. Based on the feedback from the user, the algorithm updates its hypothesis. The online algorithm does not need to be evaluated on a test set of unseen data, but on the next behavior of the user. Hence online algorithm inherently supports a drifting hypothesis, that is, it support a drift or a change of the user's preferences over time. Secondly, the algorithms [12,19] are based on structural support vector machine (SSVM) [22]. They assume that the training set is given as pairs of a feature vector and a binary label. At every round, they need a loss-augment inference with the AUC loss, which is computationally heavier than a simple inference. Our algorithm, on the other hand, assumes that each example is composed of pairs of two feature vectors: one that represents a context in which the app is used and the other represents a context where the app is not used. This might be more efficient than the used of loss-augmented inference, and leads to a strongly consistent preditor when converted to a batch algorithm. Since we are interested in the online setting in the paper, we defer the theoretical comparison to a different paper.
A important issue in practical implementation of the algorithm is how to initiate the Prediction Bar for new users, when we do not have any of their app preferences. We will discussion on this topic in the Section 5. The interested reader can find more ideas in [1].
The contribution of this paper is the following: (i) a new machine learning online algorithm for ranking the set of installed apps so as to maximized the AUC; (ii) theoretical analysis of the algorithm; (iii) a large scale empirical study on the performance of the algorithm on a real users' data.
The paper is organized as follows. In Section 2 we present previous work on predicting app usage. In Section 3 we formally state the notation and the problem definition. Then in Section 4 we describe the motivation of using the AUC as an evaluation metric. We continue with a detailed derivation of the algorithm and present its theoretical analysis in Section 5. The features used in the prediction are discussed in Section 6. Experimental results are presented in Section 7. We conclude the paper with a discussion in Section 8.

Related Work
The problem of predicting the app the user is about to use has been recently addressed by many research groups. The work in [11] was one of the first. The authors proposed an app predictor based Bayesian Networks and contextual information such as time, location, and the user profile. They evaluated their results using average prediction rate on the IDIAP/Nokia MDC dataset [13], which contains a small group of 38 users. Similarly, in [27] the author proposed a light-weighted Bayesian methods to predict the next app based on the app usage history. They also evaluated their result on the MDC dataset. Yahoo Aviate team used Bayesian Networks as a learning algorithm and evaluated it on a larger set of 480 active users, and compare their system to other standard learning algorithm [1]. They are one of the few groups who study the cold-start problem, when no data is available on the user. In [10] the temporal user's behavior was also taken into account by using an HMM-based sequence prediction.
Most works are based on contextual features related to the time, location, phone state and environment. Some authors [25,15], however, proposed to identify the usage patterns and user rating, without taking into account usage context. Interestingly, in [15] the authors propose to detect the periodicity patterns of usage by the Fourier transform, and then scoring them by Chebyshev's inequality.
Several authors based their prediction on similar users or a general group of users. Both [25,17] are based on the adaptation of a collaborative filtering algorithm as an app prediction algorithm. The work presented in [24] leverages the user-specific models by patterns of community app behaviors, guided by user similarities.
Related works also include predictions of users behavior with mobile devices. See, for example, [23,8,6,5,16], and the many refereces therein. Another set of works concerns a smart caching mechanism for fast app pre-loading [26,18].
All the works above have been focused on the maximizing the average precision or the prediction rate. In that sense our work is unique, as it proposes a new theoretically founded algorithm for the task of app prediction. Most of the works has been focused on generative models (Bayesian Networks and HMM) and our work is based on discriminative models (large margin and kernel methods). We would like to note that we found it difficult to directly compare our algorithm to previous work. The main reason is that there is no single benchmark for this tasks, and the few dataset which exists are either restricted to non-profit organizations (IDIAP/Nokia MDC dataset) or not available online (AppJoy dataset).

Problem Setting
In this section we set the notation and formally define the problem of online prediction of app usage. Our goal is to predict the most probable apps the user will use given her location, activity, time, device status, and so on. The input to the system, therefore, is a feature primitive, x ∈ X, that represents the user's contextual information as a vector of n real numbers, where X ⊂ R n is the domain of possible contextual information. The concrete representation and description of the features are discussed in Section 6.
We denote the set of user's installed apps by A, and their number by K = |A|. The Prediction Bar presents a set of k apps (currently k=4), and it is assumed that at a given context the user may click on one of the k apps (k ≤ K) with a high probability. Our goal is to find a function that outputs the set of k apps the user is about to click on, given the input context. The predicted apps should reflect their relevance according to the user's preference at the given context.
We assume that there is a score function, f : X × A → R, that assigns a score to every app a ∈ A given the user's context x ∈ X. High score of f (x, a) means that app a is relevant at context x. We define the set of all scores as F (x, A) = {f (x, a) | a ∈ A}. Define the k-sort function as a function that returns a vector of the top k ordered scores, given the set of all scores, namely, sort k : F (x, A) → R k . The argument of the k-sort function is the set of apps corresponding to the top k ordered scores. The prediction of the set of k best apps is given aŝ whereâ ∈ A k is a vector of k apps, ordered such that the most relevant app is first, the second most relevant is second, and so on. The performance of the prediction is measured by a cost function γ(a,â) between the clicked app a ∈ A and a set of k predicted appsâ, which checks the existence of the clicked app a within the setâ and returns a positive real number, namely, γ : A × A k → R + . For example, the 0-1 cost function is defined to be 0 if a ∈â and 1 otherwise, that is, where I[π] is an indicator function and it equals to 1 if the predicate π holds and 0 otherwise. If k = 1 this cost function reduces to the standard 0-1 binary loss function. In Section 4 we show that using the 0-1 cost function as a measure of performance favors the set of k most frequently used apps over other types of predictions, and we then present the reason to introduce other cost functions. We propose an online learning algorithm for predicting a set of k apps. The online algorithm maintains a set of parameters. We denote the parameters the t-th round by θ t , and indicating that by adding a subscript to the prediction function f θt . Each round corresponds to a click on an app. After each such click the algorithm updates it parameters and generates a new predictor f θt+1 . Our goal is to estimate the parameters so as to maximize the cumulative AUC along its run. We briefly review the device screen organization. A schematic screenshot of the device is depicted in Figure 1. In this particular device there are two Workspaces. A Workspace is a virtual screen where the user can place app icons and app folders. The user can change Workspaces by swiping the screen left or right. The primary Workspace is also called the Home Screen. At the bottom of all Workspaces there is a set of 5 icons which is called the App Dock. The App Dock is composed of 4 user defined app icons, while the middle icon opens the App Tray -a folder which contains all of the installed apps. On the first Workspace, above the App Dock, there is another set of 5 icons which are called the Prediction Bar. Out of those 5 icons, 4 represent apps that are automatically predicted according to the context information.

Automatic App Usage Prediction
Apps that are located on the Home Screen or on the App Dock are considered as highly available apps and they should not be considered to be predicted in the Prediction Bar. By presenting to the user apps which are already located in the same screen, we create un-necessary duplication and offer no value at all. This characteristic has an interesting implication. These highly available app clicks we avoid also tend to be the ones that are most used by the user. About 35% of app clicks are done on application shortcuts which are placed on the Home Screen or the App Dock; these clicks are distributed among only 4.6 apps on average. The rest of the clicks, i.e., the ones which occur in other locations, are distributed among 17.6 apps on average. This means that our prediction algorithm needs to focus on the 2nd-tier apps, and not on the mostly used apps. Hence, from now on we will restrict ourselves to the prediction of those apps which are not on the Home Screen.
In order to generate the automatic prediction, the device keeps track of all app clicks. For each such event the device records the time of the event, the device location (both exact coordinates as well as an indication of a recurring location), and hardware related signals (e.g., headphones connected indication, current Wi-Fi network, Bluetooth devices, etc.). Along with these fields, the position of the app on the device's screen is also recorded. Specifically we record both the relative location of the app's icon on the display (e.g., first row and third column of the secondary workspace), and if it was clicked on a special location (e.g. App Tray, App Dock, Prediction Bar, a search result, a shortcut inside a folder, etc.) -all those form the user's context feature vector x.
One of the most trivial ways to build the Prediction Bar is to constantly predict the k most frequent apps. We name this method the k Most Frequently Used, or kMFU. Formally, we define the score function for an app a as follows: where A kMFU is the set of k most used installed apps.
A bit more dynamic method combines the most frequent apps and the most recent apps and is called the Frecency algorithm. This algorithm was originally used for cache management [14], and adapted to an algorithm for predicting users' behavior [8]. Denote by t a i the time of the i-th click on app a, where there were overall n a clicks on this app in the last T days. Then the score function of an app a is defined as follows: where p and T are fixed parameters (in our setting p = 0.1 and T = 60 days performed best). Before we considered designining a new online learning algorithm, we tested the kMFU and the Frecency algorithms on our data as follows (full details in Section 7). We chose uniformly at random a set of 1000 devices that contains a total of 5,181,312 app clicks. For each device we executed both kMFU and Frecency and tried to predict a set of k = 4 apps. We checked the average 0-1 cost as in (2) of each algorithm on each device and averaged the results on all devices. This is the average precision of the algorithm, averaged on the rounds and the devices.
We found out that both kMFU and Frecency algorithms had very high precision (see Figure 2a). This, however, does not serve our goal: the kMFU algorithm simply puts the same 4 apps in the Prediction Bar, and does not predict the next app or gives a personalized feeling. The Frecency algorithm tends to predict frequent used apps and "forgets", for example, bi-weekly or weekly app click patterns.
Measuring the performance of the algorithm using precision is biased toward the frequency of the app usage. In our case a better evaluation metric would be the area under the receiver operating characteristic curve (AUC) [7]. This measure of performance tends to prefer predictions with a high true positive rate and a low false positive rate, which means that a mis-prediction of any app has the same cost no matter how frequent the app is. In the next section we derive an online algorithm that predict the next app and aims at maximizing the AUC metric.

Learning Apparatus
We saw in the previous section that the the usage of 0-1 cost function, γ(a,â) = I[a / ∈â], to assess the performance favors the set of k most used apps over other predictions. This lead to a static prediction, which does not reflect the user's instantaneous context-based app usage. We turn to describe a different measure of evaluation.
The receiver operating characteristic curve (ROC) is a graphical plot of the true positive rate (a ∈â) as a function of the false positive rate (a / ∈â). The points on the curve are obtained by sweeping the decision threshold from the most positive confidence value to the most negative one. Hence, the choice of the threshold represents a trade-off between different operational settings, corresponding to cost functions weighting false positive and false negative errors differently. Assuming a flat prior over all cost functions, it is appropriate to select the system maximizing the averaged performance over all settings, which corresponds to the model maximizing the area under the ROC curve (AUC). In the following we describe a large margin approach which aims at predicting a set of apps which achieves a high AUC.
Let us denote by X a,+ the set of contexts (location, times, WiFi networks, etc.) where app a is clicked. Similarly denote by X a,− the set of contexts where app a is never clicked. The AUC can be defined as [2,9] where x a,+ ∈ X a,+ and x a,− ∈ X a,− . That is, the AUC is the probability that the confidence for app a in a context that it is clicked is higher than the confidence where it is not clicked. The probability is over a triplet (x a,+ , x a,− , a) drawn from a fixed unknown distribution ρ.
Our goal is find the parameters θ that maximizes the AUC, namely or equivalently, where the expectation is with respect to the distribution ρ. Since the distribution ρ is unknown, this optimization problem cannot be solved directly. For methodological reasons we will first discuss the batch setting, where a training set of m examples are sampled from the distribution ρ. We replace the expectation with the sample average and add a regularization factor to avoid overfitting. The objective is now where λ is a trade-off parameter between the loss term and the regularization. Conventionally, we replaced the max operation with a min operation while changing the direction of the inequality sign. Still, we cannot optimize this objective since the summands are indicator functions, a combinatorial quantity that is hard to be minimized directly. Different learning algorithms use various surrogate loss function to approximate this function. Here we focused on large margin based algorithms, which replaces it with a convex upper bound surrogate loss called hinge loss we describe in the next subsection.

A Large Margin Algorithm for App Ranking
Building on techniques used for learning multiclass [4] and structured prediction classifiers [21,22], our set of prediction functions distills to a classifier in this vector-space which is aimed at separating the relevant apps from irrelevant ones. We focus on the following set of linear prediction functions: where θ ∈ R d are the model parameters , and ϕ : X × A → R d is a set of functions called feature functions or feature maps. Each feature function gets as input a feature primitive x and an app a and returns a scalar which, intuitively, should be correlated with whether the app a is used in context of x. For example, one such function might be how many times the app a was clicked in a radius of 50 meters around the location xyz. Refer to Section 6 for mode details. Methods like support vector machines (SVMs) replace the summands of (8) with their corresponding convex upper bound called hinge loss. Denote [π] + = max{π, 0}, then in our case: We define the hinge surrogate loss as follows: Using this surrogate loss instead of the cost in the objective (8), and using the 2 regularization, we get the structural SVM algorithm for maximizing the AUC in our setting This is a convex function in its parameters and its solution can be found using the cutting plane method [22] or by stochastic sub-gradient descent [20]. In out setting we are interested in optimizing the set of parameters for each user separately on the device. Moreover we would like to handle scenarios where the users preferences changes over time. Hence we turn to online learning algorithm.

An On-line Algorithm
We now describe an online algorithm for learning the parameters, while maximizing the AUC instantaneously. It is a variant of the Passive-Aggressive algorithm [3] for maximizing the AUC which we call AUC-PA. The online algorithm works in rounds, and updates its parameters every round. Set the initial parameters to θ 0 = 0. While the model extends prediction for every context, a learning round is defined by the event of app click. At the t-th round, when the device is at context x t , the algorithm predicts a set of k appsâ t using the set of parameters θ t−1 The set of predicted appsâ k t are presented to the user. The user clicks on an app a t either from the set of k presented apps or from the whole set of the n installed apps A.
For each app a we keep a set X a,− of randomly chosen context, where the app a is never clicked by the user. Once we know the user clicked the app a t , we extract uniformly at random x at,− ∈ X at,− . We then predict the most relevant app given the new feature primitivê The model then suffers a loss (x at,+ t , x at,− t , a t , θ t−1 ), defined in (13) or equivalently and updates the parameters as follows The solution of this optimization problem is [3] where The overall algorithm is described in Algorithm 1.

Analysis
We show that our online algorithm attains a high cumulative AUC after T rounds, defined as follows where θ 1 , . . . , θ T are the weight vectors obtained by the algorithm. The examination of the cumulative AUC is of great interest as it provides an estimator for the generalization performance. Note that at each round the algorithm can be considered as receives new example (x at,+ t , x at,− t , a t ) and predicts an app that is best suitable to x at,− t using the previous weight vector θ t−1 . Only after the predictionâ − t is made the algorithm suffers loss. The cumulative AUC is a weighted sum of the performance of the algorithm on the next unseen training example and hence it is a good estimation to the performance of the algorithm on unseen data during training.
The following theorem states a competitive bound. It compares the cumulative AUC of the weight vectors series, {θ 1 , . . . , θ T }, resulted from the online algorithm to the best fixed weight vector, θ , chosen in hindsight, and essentially proves that, for any sequence of examples, our algorithms cannot do much worse than the best fixed weight vector. Formally, it shows that the cumulative area above the curve, 1 − AUC, is smaller than the weighted average loss (x at,+ t , x at,− t , a t , θ t−1 ) of the best fixed weight vector θ and its weighted complexity. That is, the cumulative AUC of the iterative training algorithm is going to be high, given that the loss of the best solution is small, the complexity of the best solution is small and that there are reasonable number of rounds, T .
t=1 be a set of training examples and assume that we have ϕ(x, a) ≤ 1/ √ 2 for all x and a. Let θ be the best weight vector selected under some optimization criterion by observing all instances in hindsight. Then, where λ ≤ 1 and AUC is the cumulative AUC defined in (21).
Proof. Denote by t (θ) the instantaneous loss the weight vector θ suffers on the t-th round, that is, t (θ) = (x at,+ t , x at,− t , a t , θ t−1 ). The proof of the theorem relies on Lemma 1 and Theorem 4 in [3]. Lemma 1 in [3] implies that, Now if the algorithm makes a prediction mistake and the predicted confidence of appâ − in x at,− t is higher than the confidence of the app a t in x at,+ T then t (θ t−1 ) ≥ 1. Using the assumption that ϕ(x, a) ≤ 1/ √ 2, which in turn means that ϕ(x at,+ , a t ) − ϕ(x at,− ,â − t ) 2 ≤ 1, and the definition of τ t given in (20), we conclude that if a prediction mistake occurs then it holds that Summing over all the prediction mistakes made on the entire set of examples and taking into account that τ t t (θ t−1 ) is always non-negative, we have Again using the definition of τ t , we know that τ t t (θ ) ≤ t (θ )/λ and that τ t ∆ϕ t 2 ≤

Feature Primitives and Feature Functions
All our features are based on basic primitives that are measured from the device. The feature primitives denoted x ∈ X ⊂ R n . They are the device time and date, the device location, and hardware related signals (e.g., headphones connected indication, current Wi-Fi network, Bluetooth devices, etc.). On the top of the feature primitives, we design a set of feature functions which allow us to incorporate into the feature design the presumed app. The idea is that each feature function takes as input a vector of feature primitives x, which describes the context information, and an app a, and returns a scalar which should be related to whether the app a corresponds to the the user's preference at context x. The feature functions map the context vector x along with a proposed app a to a vector of fixed dimension in R d .
Our feature functions have two sets of representations: contextual features and appdependent features. Before turning to describe the actual feature, we define them formally. The set of contextual features is composed of a set of non-linear functions of the feature primitives x and denoted as ψ(x), where ψ : X → R d ψ , where d ψ is the number of contextual features. The set of app-dependent features is a non-linear functions of the feature primitives x and the app a and denoted φ(x, a), where φ : The new score function is of the form: where w ∈ R d φ and w a ∈ R d ψ for all a ∈ A are the weight vectors that replace θ. While this function looks somewhat different from the score in (9), it is straightforward to show the form in (9) is more general. Moreover, the context features could all have been represented as app-dependent features. However, in our setting it is more efficient and convenient to keep both set of feature representations. This allows us to manage memory of the context features in a sparse way.

Contextual Features
Contextual features represent the state of the device, and they are expressed as a set of functions over the feature primitives, such as day-of-week, headphones connected, and knownlocation are used and describe in detail below. While the contextual feature do not depend on any specific app, they are weighed from each app separately. It means that we expect to have a high weight for when the feature day-of-week equals Saturday for the app BestParking.
We describe now the context feature vector ψ(x) that are common to all apps. The first set of features is time-based features and includes the following features The second set is location-based features. These features are based in the notion of known location. Known location is defined as a recurring location, that was visited within 50 meters in the last month.
for h in {60, 600, 1500} seconds. The function ∆ SecOfDay (t, t s ) is the difference between absolute times t and t s , translated to seconds of day.
The third set of feature functions score the apps based on the locations it is used. Let l be the current location in terms of latitude-longitude. Let L a be the set of the locations the app a was used (latitude-longitude). Let ∆ LatLong (l, l s ) be the distance in meters between the location l and the location l s , then,

Experimental Results
In this section we present the performance of our algorithm against other algorithms with different evaluation metrics. We start by comparing the accuracy of the proposed algorithm to other algorithms and with different evaluation metrics. Then, we verify our results with different number of users on different time periods. We continue with an experiment that check the accuracy and the convergence of the online algorithm over time. We conclude with results on the influence of the app ranking on its accuracy.
The data was collected from a set of 1000 randomly selected users which were active users of EverythingMe Launcher for 180 days. This set containing 5,181,312 app-click entries.

App prediction performance
We start by comparing the performance of the online algorithm with the kMFU algorithm and the Frecency algorithm. We randomly selected 1000 devices and extracted their data for time span of 180 days. Specifically we extracted the context information at times which correspond to app-click events. Then, for each such event, we extract a vector of feature primitives and feature functions and predict a set of 4 apps using kMFU, Frecency and AUC-PA. We compared the predictions of the algorithms with the actual app that was clicked. The performance results are given in Figure 2. We present 3 evaluation metrics: (a) precision -for each device we count the times the predicted app is also the clicked app, and then average over all devices ; (b) per-app precision -for each device and for each app we checked the precision, then averaged over all apps and devices; (c) AUC -for each device we computed the AUC and averaged over devices. Note that AUC cannot be computed to kMFU, since it constantly predicts the same k apps and only them.
Recall that the kMFU algorithm always predicts the same k apps -the most frequent ones. As expected it has the best precision compared to Freceny and AUC-PA. On the other hand when comparing the per-app precision and the AUC, the AUC-PA outperforms kMFU and Frecency.

Prediction Quality Over Time
In the next experiment we analyze the quality of the prediction over the entire time period. We use the same randmoly selected group of 1000 devices, and calculate the (a) per-app precision and (b) AUC in a sliding window of one week. That is, each point in the following graph represents a time period of one week starting 3 days beforehand and ending 3 days afterwords.
We consider the performance of the algorithms over since it is installed on the device and on, that is we would like to understand the behavior over time and how it converges over time. This is very important issue, mainly in order to understand how fast prediction would be relevant for new users (the cold start problem).
We can see that all algorithms reach stable performance in the first couple of days, and maintain the same performance throughout the entire time period. AUC-PA outperforms Frecency and kMFU consistently both in the AUC as well as with the per-app precision.
Something that's worth noting is the fact that as time passes, the prediction algorithms need to take into consideration more apps. According to the test data, the average amount of distinct apps used by a user accumulated over 30 days is 30.23, after 90 days is 57.92 and after 180 days, 76.14. A simple explanation for this increase is that most apps have a limited lifetime on user's devices. Some apps are installed, used for some time and then forgotten or uninstalled. Other apps are simply used very rarely.
Both kMFU and Frecency ignore the lesser-used apps by design, as both favour the more used apps. It is therefore interesting to see that in spite the increase in the amount of possible predictions AUC-PA keeps a stable per-app precision rate. This demonstrates the ability of the prediction algorithm to adapt to a moving hypothesis.

Performance versus the usage-rank
This final experiment demonstrates the ability of AUC-PA to predict from the long-tail of lesser-used apps. As previously stated, the average user will use on average 17.6 2nd-tier apps during a single month (i.e. ones which are not positioned on the App Dock or the Home Screen). We therefore assign for each app and device a usage-rank -0 for the most used app, 1 for the second most used app and so on. Next, we average on all devices the prediction precision of all of the n-ranked apps.
As expected, kMFU performs very well on ranks 0-3 and very badly on the rest. This is a direct result of the fact that it always returns the k most used apps, k = 4 in our setting. Frecency performs slightly worse for the most used apps and slightly better for the Per−app average precision q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q (a) Per-app precision Days since install AUC q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q (b) AUC lesser ranked apps, although by the time we reach the 10th place performace is quite poor. AUC-PA shows significantly better results for the apps with lower ranks, while taking a hit in the top-ranked apps.

Discussion
In this paper we presented an algorithm for predicting the set of apps the user will probably use, based on the device's contextual information (time, location, etc.). The algorithm was designed to optimize the user's personalization and to promote the prediction of less used apps in an appropriate context by aiming at the maximization of AUC, rather than simply the raw clicks. The algorithm runs efficiently on the device in an online fashion and constantly updates its hypothesis to handle changes in user's preference over time.
In a set of experiments we showed that the algorithm attains high performance when evaluated using AUC or when evaluated using the normalized precision (frequently and rarely used apps are weighted the same). We also showed that the algorithm converges, on the average, within few days. Last we showed that the algorithm attains a high prediction rate for those apps which are ranked below the most used apps.
Future work is focused on finding new features to improve performance in general. More specifically, we are interested in including features that indicate the user is located in a special point-of-interest, like a school, an airport, or a shopping mole. Such features, for example, will allow the algorithm to support a different set of app preferences at those location. Another possible direction which we are investigating now is the option to suggest the user to install a new app that would fits its preference in a given context. Another interesting direction that we will explore in future work is a sequential modeling of app usage.