Google news personalization: scalable online collaborative filtering

Abhinandan DasMayur DatarAshutosh GargShyam Rajaram

article2007WWW1,822 citations

Presents a scalable, production-tested collaborative filtering architecture that combines MinHash clustering, MapReduce-based PLSI, and covisitation tracking to deliver real-time news recommendations across millions of dynamic items and users with high churn.

Listen

Online news platforms face the critical challenge of delivering timely, personalized story recommendations to millions of active visitors while content rapidly updates and expires every few hours. Traditional collaborative filtering systems typically assume a relatively stable catalog of items and rely on computation-heavy offline updates. In fast-moving news environments, however, user interests are immediate and older stories quickly become obsolete. Consequently, platforms require an architecture capable of processing massive data volumes and continuously refreshing recommendations within milliseconds.

The article demonstrates the design, deployment, and real-world performance of a scalable, real-time collaborative filtering system designed to generate personalized recommendations under conditions of extreme content turnover and large user scale.

To solve this, the system combines three distinct algorithmic approaches: two scalable user-clustering methods and an item-to-item co-occurrence method that identifies stories frequently read together within short time windows. Offline clustering jobs group similar readers across months of activity, while distributed online data stores track time-decayed reader activity and update scores immediately when a user clicks an article. A live production evaluation was conducted over five to six months across millions of active readers, comparing click-through performance against standard popularity-based recommendations.

The evaluation revealed several key findings. First, personalization substantially improves user engagement, as personalized recommendations achieved approximately 38% higher click-through rates compared to a baseline strategy of simply showing popular stories. Second, the advanced probabilistic clustering and hashing methods consistently outperformed conventional memory-based correlation techniques in accuracy without sacrificing operational speed. Third, the system demonstrated high operational resilience; separating real-time statistics updates from recommendation serving ensured that recommendations could still be generated quickly even if tracking components experienced brief outages. Finally, the baseline popularity algorithm only outperformed personalization during rare breaking news events involving broad, universal audience interest.

These findings show that large-scale recommendation systems can remain fully content-agnostic and rely strictly on user interaction data. By avoiding text-based analysis, the underlying infrastructure can be adapted across multiple languages and media formats, such as video, music, or images, with minimal reconfiguration. Furthermore, isolating real-time scoring from periodic clustering drastically reduces computational bottlenecks and operational risk while meeting strict sub-second web latency requirements.

Organizations operating high-volume, dynamic content services should consider adopting hybrid architectures that blend long-term behavioral clustering with short-term co-visitation tracking. Future efforts should focus on automated machine learning techniques to dynamically weight algorithm scores and on refining how new users with little interaction history are integrated into clustering models.

While the live results provide high confidence in the overall architecture's effectiveness, the system relies on implicit click data, which can introduce noise from accidental selections or automated traffic. In addition, the probabilistic clustering models still require batch retraining to incorporate newly registered users, temporarily relying on simpler co-visitation methods for recent accounts.

Google University of Illinois Urbana-Champaign collaborative filtering engine linear models scalable online collaborative filtering Google news personalization MinHash clustering

Das et al (2007).pdf

Paper: Probabilistic latent semantic indexing, Thomas Hofmann (1999). It introduces Probabilistic Latent Semantic Indexing (PLSI), one of the core foundational latent-variable models that Google News adapts for collaborative filtering.
Paper: Amazon.com recommendations: item-to-item collaborative filtering, Greg Linden et al. (2003). It introduces scalable item-to-item collaborative filtering and covisitation logic that direct industrial news recommender systems build upon.
Paper: Item-based collaborative filtering recommendation algorithms, Badrul Sarwar et al. (2001). It establishes item-based collaborative filtering methodologies that underpin large-scale recommender architectures.
Paper: Empirical Analysis of Predictive Algorithms for Collaborative Filtering, John S. Breese et al. (1998). It provides the foundational empirical comparison of memory-based and model-based collaborative filtering techniques.
Paper: GroupLens: An open architecture for collaborative filtering of netnews, Paul Resnick et al. (1994). It presents the seminal collaborative filtering architecture for personalized news delivery, defining the problem domain addressed by Google News.
Paper: Toward the next generation of recommender systems: a survey of the state-of-the-art and possible extensions, Gediminas Adomavicius et al. (2005). It surveys the state-of-the-art and foundational limitations of collaborative, content-based, and hybrid recommender systems.
Paper: SimRank: a measure of structural-context similarity, Glen Jeh et al. (2002). It provides the structural context similarity principles used in graph- and co-occurrence-based item recommendation.
Paper: Indexing By Latent Semantic Analysis, Scott Deerwester et al. (1990). It establishes Latent Semantic Analysis, the theoretical precursor to the probabilistic topic modeling used in the target paper.

Paper: A contextual-bandit approach to personalized news article recommendation, Lihong Li et al. (2010). It advances dynamic news recommendation by framing article selection as a contextual bandit problem to overcome cold-start and rapid content churn.
Paper: Collaborative Filtering for Implicit Feedback Datasets, Yifan Hu et al. (2008). It develops a formal matrix factorization framework explicitly designed for implicit feedback signals like the click and covisitation data used in news personalization.
Paper: Matrix Factorization Techniques for Recommender Systems, Yehuda Koren et al. (2009). It generalizes modern latent factor and matrix factorization techniques for large-scale industrial collaborative filtering.
Paper: BPR: Bayesian Personalized Ranking from Implicit Feedback, Steffen Rendle et al. (2009). It introduces a Bayesian personalized ranking objective tailored directly for learning from implicit feedback logs.
Paper: Wide & Deep Learning for Recommender Systems, Heng-Tze Cheng et al. (2016). It extends industrial-scale recommendation pipelines by combining linear models for memorization with deep neural architectures for generalization.
Paper: Collaborative filtering with temporal dynamics, Yehuda Koren (2009). It builds upon collaborative filtering by explicitly capturing temporal drift in both user preferences and item popularity over time.
Paper: Neural Collaborative Filtering, Xiangnan He et al. (2017). It evolves collaborative filtering beyond linear and latent semantic models by utilizing deep neural networks to learn complex user-item interaction functions.
Paper: Session-based Recommendations with Recurrent Neural Networks, Balázs Hidasi et al. (2016). It shifts from static user-history collaborative filtering to session-based sequential modeling using recurrent neural networks.

Cover for Google news personalization: scalable online collaborative filtering

Abstract

Several approaches to collaborative filtering have been studied but seldom have studies been reported for large (several million users and items) and dynamic (the underlying item set is continually changing) settings. In this paper we describe our approach to collaborative filtering for generating personalized recommendations for users of Google News. We generate recommendations using three approaches: collaborative filtering using MinHash clustering, Probabilistic Latent Semantic Indexing (PLSI), and covisitation counts. We combine recommendations from different algorithms using a linear model. Our approach is content agnostic and consequently domain independent, making it easily adaptable for other applications and languages with minimal effort. This paper will describe our algorithms and system setup in detail, and report results of running the recommendations engine on Google News.

Topics

collaborative filtering engine linear models personalizations recommendation semantics personalized recommendation latent factor latent variable clustering methods

Keywords

scalable online collaborative filtering Google news personalization MinHash clustering locality-sensitive hashing Latent Dirichlet Allocation Latent Semantic Indexing real time recommendation Bigtable infrastructure

1. INTRODUCTION
2. PROBLEM SETTING
2.1 Scale of our operations
2.2 The problem statement
2.3 Strict timing requirements
3. RELATED WORK
3.1 Memory-based algorithms
3.2 Model-based algorithms
4. ALGORITHMS
4.1 MinHash
4.1.1 LSH
4.1.2 MinHash clustering using MapReduce
4.2 PLSI
4.2.2 Using PLSI with Dynamic Datasets
4.3 Using user clustering for recommendations
4.4 Covisitation
4.5 Candidate generation
5. SYSTEM SETUP
5.1 Offline processing
5.2 Data tables
5.3 Real time servers
5.4 Putting the components together
6. EVALUATION
6.1 Test Datasets
6.2 Evaluation methodology and metrics
6.4 Evaluation Results
6.5 Evaluation on live traffic
7. CONCLUSION
8. ACKNOWLEDGMENTS
9. REFERENCES

Knowls

Knowl 1 — MinHash-Based Locality Sensitive Clustering for Binary User Click Histories
algorithm
MinHash clustering groups users with overlapping item interaction histories by applying Locality Sensitive Hashing (LSH) over Jaccard similarity. Each user $u \in \mathcal{U}$ is represented by a set of clicked news stories $C_u \subseteq \mathcal{S}$ . The similarity between two users $u_i, u_j$ is given by the Jaccard coefficient:

$S(u_i, u_j) = \frac{|C_{u_i} \cap C_{u_j}|}{|C_{u_i} \cup C_{u_j}|}$

Under a uniform random permutation of the item universe $\mathcal{S}$ , the probability that the first item from $C_{u_i}$ matches the first item from $C_{u_j}$ equals $S(u_i, u_j)$ . To construct robust user clusters without storing permutations across millions of items, 64-bit hash values are generated using independent random seeds:
Input: User click history $C_u \subseteq \mathcal{S}$ , number of hash functions per group $p$ , number of groups $q$ , independent random seeds $\sigma_{l,m}$ for $1 \le l \le q, 1 \le m \le p$
Output: Set of $q$ cluster IDs for user $u$
for each group $l \leftarrow 1$ to $q$ do
     $K_l \leftarrow$ empty string
    for each hash index $m \leftarrow 1$ to $p$ do
         $h_{\min} \leftarrow \infty$
        for each item $s \in C_u$ do
             $h \leftarrow \text{Hash64}(\text{Id}(s), \sigma_{l,m})$
            if $h < h_{\min}$ then
                 $h_{\min} \leftarrow h$
            end if
        end for
         $K_l \leftarrow K_l \mathbin{\Vert} \text{String}(h_{\min})$
    end for
    Emit cluster membership $(K_l, u)$
end for
Key design properties include:
- Concatenating $p$ hash values ( $p \in [2, 4]$ ) raises the collision probability to $S(u_i, u_j)^p$ , increasing cluster precision.
- Generating $q$ independent concatenated keys ( $q \in [10, 20]$ ) increases recall across candidate clusters.
- The 64-bit integer hash range ( $0 \dots 2^{64}-1$ ) prevents collisions up to an item universe of $2^{32}$ items.
- In a MapReduce pipeline, Mappers compute the $q$ cluster IDs per user, the Shuffle phase groups users by cluster ID, and Reducers emit user lists per cluster, pruning clusters whose membership falls below a minimum threshold.
Knowl 2 — Parallel Expectation-Maximization for Probabilistic Latent Semantic Indexing via 2D Grid Sharded MapReduce
algorithm
Probabilistic Latent Semantic Indexing (PLSI) models user-item interactions $(u, s) \in \mathcal{U} \times \mathcal{S}$ via an unobserved latent community variable $z \in \mathcal{Z}$ with $|\mathcal{Z}| = L$ classes:

$p(s|u; \theta) = \sum_{z=1}^L p(z|u) p(s|z)$

For large-scale click logs where the number of users $N = |\mathcal{U}|$ and items $M = |\mathcal{S}|$ are on the order of $10^7$ and $L = 1000$ , standard single-machine Expectation-Maximization (EM) memory requirements exceed single-node capacities. The EM algorithm is parallelized across an $R \times K$ grid of Mapper workers:
Input: Sharded click log containing pairs $(u, s)$ , prior parameter estimates $\hat{p}(z|u)$ , $N(z, s)$ , and $N(z)$
Output: Updated conditional probability distributions $p(z|u)$ and $p(s|z)$
Mapper at grid coordinate $(i, j)$ for user shard $i \in \{1,\dots,R\}$ and item shard $j \in \{1,\dots,K\}$ :
    Load local parameters $\hat{p}(z|u)$ for $u \in \text{Shard}_i$ and $N(z, s)$ for $s \in \text{Shard}_j$
    for each observed click pair $(u, s)$ where $u \in \text{Shard}_i$ and $s \in \text{Shard}_j$ do
        for each latent state $z \in \mathcal{Z}$ do
             $q^*(z; u, s; \hat{\theta}) \leftarrow \frac{\frac{N(z, s)}{N(z)} \hat{p}(z|u)}{\sum_{z' \in \mathcal{Z}} \frac{N(z', s)}{N(z')} \hat{p}(z'|u)}$
        end for
        Emit intermediate pairs: $(u, q^*)$ , $(s, q^*)$ , and $(z, q^*)$
    end for
Reducer for User $u$ :
     $p(z|u) \leftarrow \frac{\sum_s q^*(z; u, s; \hat{\theta})}{\sum_{z'} \sum_s q^*(z'; u, s; \hat{\theta})}$
    Emit updated CPD $p(z|u)$
Reducer for Item $s$ :
     $N(z, s) \leftarrow \sum_u q^*(z; u, s; \hat{\theta})$
    Emit updated statistic $N(z, s)$
Reducer for Latent State $z$ :
     $N(z) \leftarrow \sum_s \sum_u q^*(z; u, s; \hat{\theta})$
    Emit updated statistic $N(z)$
The conditional probability distribution for items is obtained via $p(s|z) = \frac{N(z, s)}{N(z)}$ . Sharding users into $R$ shards and items into $K$ shards ensures each Mapper only loads $1/R$ of user parameters and $1/K$ of item statistics, bounding per-machine memory consumption to $(N/R + M/K) \times L \times 4$ bytes.
Knowl 3 — Dynamic Real-Time PLSI Adaptation for High-Churn Itemsets
model/method
In news recommendation systems, the item set undergoes constant churn (frequent insertions and deletions every few minutes), which invalidates offline-learned static item parameters $p(s|z)$ and makes full retraining infeasible.

To adapt PLSI to dynamic itemsets in real time:
1. The user conditional probability distributions $p(z|u)$ are learned offline via MapReduce and treated as fixed fractional memberships across $L$ user community clusters $z \in \mathcal{Z}$ .
2. For each cluster $z$ and each active or newly published story $s$ , an online weighted click count is maintained in real time.
3. When user $u$ clicks on story $s$ , the online counter for every cluster $z$ is updated by the fractional weight $p(z|u)$ discounted by an exponential time-decay factor.
4. The item distribution given latent class $z$ is dynamically normalized on the fly:
$p(s|z) = \frac{\text{DecayedWeightedClicks}(s, z)}{\sum_{s' \in \mathcal{S}} \text{DecayedWeightedClicks}(s', z)}$

This enables newly published articles to acquire real-time PLSI scores immediately as cluster members interact with them.
Knowl 4 — Time-Decayed Item-Item Covisitation Graph for Real-Time Short-Term Recommendations
model/method
Item-item covisitation models short-term user interests based on stories clicked within a brief time window (typically a few hours).

The system maintains an online graph in distributed storage where nodes represent news stories $\mathcal{S}$ and edge weights represent time-decayed counts of covisitation instances. An edge $(s_j, s_k)$ exists if a user clicks both $s_j$ and $s_k$ within the time window.

Online updates upon user click:
- When user $u_i$ clicks story $s_k$ , the system retrieves $u_i$ 's recent click history $C_{u_i}$ .
- For every prior recent item $s_j \in C_{u_i}$ , the adjacency lists for both $s_j$ and $s_k$ are updated in real time with an age-discounted count increment.
Candidate recommendation scoring: For a candidate item $s$ and a user $u_i$ with recent click history $C_{u_i}$ , the covisitation score is:

$r^{\text{covisit}}_{u_i, s} = \sum_{s_j \in C_{u_i}} \frac{\text{Weight}(s_j, s)}{\sum_{s' \in \mathcal{S}} \text{Weight}(s_j, s')}$

The raw covisitation scores are normalized via linear scaling to the range $[0, 1]$ .
Knowl 5 — Unified Linear Combination Scoring for Hybrid Multi-Algorithm Recommendations
model/method
To combine long-term user interests with immediate short-term session intent, recommendation scores from multiple model-based and memory-based algorithms are combined via a linear model:

$r_{u_a, s_k} = \sum_{a \in \mathcal{A}} w_a r^a_{s_k}$

where $\mathcal{A} = \{\text{MinHash}, \text{PLSI}, \text{Covisitation}\}$ , $w_a$ is the weight assigned to algorithm $a$ , and $r^a_{s_k} \in [0, 1]$ is the normalized candidate score produced by algorithm $a$ .

For user-clustering methods (MinHash and PLSI), the candidate score $r_{u_a, s_k}^{\text{cluster}}$ is computed as:

$r_{u_a, s_k}^{\text{cluster}} \propto \sum_{c_i : u_a \in c_i} w(u_a, c_i) \left( \frac{\sum_{u_j \in c_i} I(u_j, s_k)}{\sum_{s' \in \mathcal{S}} \sum_{u_j \in c_i} I(u_j, s')} \right)$

where $w(u_a, c_i)$ is the fractional membership of user $u_a$ in cluster $c_i$ (equal weights across matching hash buckets for MinHash; $p(z=c_i|u_a)$ for PLSI), and $I(u_j, s_k)$ represents the time-decayed click indicator of member $u_j$ on story $s_k$ .

The top $K$ candidate stories ranked by $r_{u_a, s_k}$ are returned to the user.
Knowl 6 — Decoupled Online Serving and Asynchronous Statistics Architecture for Real-Time Recommendations
model/method
The recommendation system separates real-time scoring from statistics aggregation using two distributed Bigtable data tables and decoupled serving components:
1. Data Tables:
  - User Table (UT): Indexed by user ID; stores the user's cluster IDs (MinHash buckets and PLSI latent classes) and click history.
  - Story Table (ST): Indexed by story ID; stores real-time time-decayed cluster click counts ( $s \times c$ ) and item covisitation adjacency lists ( $s \times s'$ ), along with normalizer sums.
2. Serving Workflows:
  - Recommendation Serving: The News Frontend (NFE) passes the user ID and candidate story IDs to the News Personalization Server (NPS). The NPS retrieves the user's clusters and recent history from the UT, fetches cluster click counts and covisitation statistics from the ST (with local caching and expiry windows), computes the combined linear scores, and returns the top ranked stories within a strict sub-second latency budget (a few hundred milliseconds).
  - Click Ingestion: When a user clicks a story, the NFE records the click in the UT and notifies the News Statistics Server (NSS). The NSS fetches the user's cluster memberships and recent click history from the UT and updates cluster click counts and covisitation pairs in the ST, buffering writes for throughput.
Decoupling NPS from NSS ensures that if the NSS fails or lags, the NPS continues serving recommendations using slightly stale ST statistics, achieving graceful degradation without user-facing downtime.
Knowl 7 — Candidate Generation for Online News Recommendation
algorithm
Generating recommendation scores for millions of available news items in real time is computationally prohibitive. A candidate set $\mathcal{C}_{u}$ of items for user $u$ is formed using either of two methods:
Input: User $u$ , user cluster set $\mathcal{K}_u$ , user recent click history $C_u$ , item covisitation graph $\mathcal{G}_{\text{covisit}}$
Output: Candidate story set $\mathcal{C}_u$
Method 1 (System Candidate Set):
     $\mathcal{C}_{\text{cluster}} \leftarrow \bigcup_{c \in \mathcal{K}_u} \{s \in \mathcal{S} \mid \text{Clicks}(c, s) > 0\}$
     $\mathcal{C}_{\text{covisit}} \leftarrow \bigcup_{s' \in C_u} \{s \in \mathcal{S} \mid (s', s) \in \mathcal{G}_{\text{covisit}}\}$
     $\mathcal{C}_u \leftarrow \mathcal{C}_{\text{cluster}} \cup \mathcal{C}_{\text{covisit}}$
    return $\mathcal{C}_u$
Method 2 (Frontend Candidate Filtering):
     $\mathcal{C}_{\text{frontend}} \leftarrow \text{FilterStories}(\text{edition}, \text{language}, \text{freshness}, \text{custom\_sections})$
     $\mathcal{C}_u \leftarrow \mathcal{C}_{\text{frontend}}$
    return $\mathcal{C}_u$
Method 1 defines the minimal sufficient candidate set because stories outside the union of cluster clicks and covisitation neighbors receive a score of zero under the scoring model, bounding candidate evaluation to at most a few thousand items per user request.
Knowl 8 — Precision-Recall Evaluation of MinHash, PLSI, and Correlation on Static Datasets
empirical result
Offline evaluations were conducted across three datasets:
- MovieLens: 943 users, 1,670 movies, ~54,000 ratings (binarized to 1 if rating $\ge$ user's mean rating, 0 otherwise).
- NewsSmall: 5,000 users, 40,000 items, 370,000 clicks.
- NewsBig: 500,000 users, 190,000 items, 10,000,000 clicks.
Evaluations used an 80%-20% train-test split per user across multiple runs. Inferred ratings were binarized across thresholds in $\{10^{-x} \mid x \in [0.1, 4.0]\}$ .

Key empirical findings:
- PLSI achieved the highest precision across all recall levels, followed by MinHash clustering.
- Both PLSI and MinHash outperformed the standard memory-based Pearson/Cosine Correlation benchmark on MovieLens and NewsSmall.
- Memory-based Correlation failed to scale to NewsBig because keeping the pairwise user matrix in memory or querying disk in real time became computationally infeasible, whereas MapReduce-based PLSI and MinHash scaled efficiently.
- The precision-recall quality difference between PLSI and MinHash narrowed as the dataset size increased from MovieLens to NewsBig.
Knowl 9 — Interlaced A/B Testing Methodology for Position-Unbiased Live Recommendation Evaluation
experimental setup
To evaluate competing recommendation algorithms on live web traffic without presentation or position bias (where users preferentially click higher-ranked positions):
1. Two or more candidate algorithms generate independent sorted ranked recommendation lists for a user request.
2. The final presented recommendation list is constructed by interlacing items round-robin from the competing lists (e.g., item 1 from Algorithm A, item 1 from Algorithm B, item 2 from Algorithm A, item 2 from Algorithm B, removing duplicate items).
3. The starting algorithm order in the interlace sequence is systematically cycled across user requests so each algorithm appears at each position rank with equal frequency.
4. Relative performance is measured by tracking user clicks attributed to each algorithm's recommended items. The ratio of click-throughs across a shared baseline provides an unbiased comparison of recommendation quality.
Knowl 10 — Live Traffic Click-Through Rate Improvement over Popularity Baseline on Google News
empirical result
In live traffic A/B testing conducted over millions of Google News users across 5 to 6 months:
- Hybrid collaborative filtering algorithms biased toward item covisitation (weight $= 2.0$ , denoted CVBiased) and biased toward user clustering (weight $= 2.0$ for PLSI and MinHash, denoted CSBiased) were compared against a baseline algorithm that recommends the most popular stories ranked by age-discounted total clicks.
- On average, both CVBiased and CSBiased achieved a 38% higher click-through rate (CTR) compared to the Popular baseline.
- The Popular baseline only outperformed personalized collaborative filtering during rare, highly viral breaking events (e.g., major celebrity news events).
- Direct live comparisons between MinHash and PLSI showed that while individual standalone models (weights 1:1:0 or 1:0:1) performed better than an unweighted equal blend (1:1:1), neither MinHash nor PLSI showed a statistically conclusive advantage over the other.

Coverage note — No substantial contributed material was omitted. The 10 knowls fully cover the system architecture, MinHash and PLSI MapReduce formulations, dynamic real-time adaptation, covisitation modeling, candidate generation, and offline and live experimental evaluations.

References

1.G. Adomavicius, and A. Tuzhilin Toward the Next Generation of Recommender Systems: A Survey of the State-of-the-Art and Possible Extensions. In IEEE Transactions on Knowledge And Data Engineering, Vol 17, No. 6, June 2005
2.D. Blei, A. Ng, and M. Jordan Latent Dirichlet Allocation In Journal of Machine Learning Research, 2003.
3.J. Breese, D. Heckerman, and C. Kadie Empirical Analysis of Predictive Algorithms for Collaborative Filtering. In Proc. of the 14th Conf. on Uncertainty in Artifical Intelligence, July 1998.
4.A. Broder. On the resemblance and containment of documents. In Compression and Complexity of Sequences (SEQUENCES'97), 1998, pp. 21–29.
5.J. Buhler Efficient large-scale sequence comparison by locality-sensitive hashing. In Bioinformatics, Vol. 17, pp 419 –428, 2001.
6.M. Charikar. Similarity Estimation Techniques from Rounding Algorithms. In Proc. of the 34th Annual ACM Symposium on Theory of Computing, STOC (2002).
7.N. Cristianini, and J. Shawe-Taylor An Introduction to Support Vector Machines and Other Kernel-based Learning Methods Cambridge University Press, 1st edition (March 28, 2000).
8.E. Cohen. Size-Estimation Framework with Applications to Transitive Closure and Reachability. Journal of Computer and System Sciences 55 (1997): 441–453.
9.E. Cohen, M. Datar, S. Fujiwara, A. Gionis, P. Indyk, R. Motwani, J. Ullman, and C. Yang. Finding Interesting Associations without Support Pruning. In Proc. of the 16th Intl. Conf. on Data Engineering, (ICDE 2000).
10.F. Chang, J. Dean, S. Ghemawat, W. Hsieh, D. Wallach, M. Burrows, T. Chandra, A. Fikes, and R. Gruber. Bigtable: A Distributed Storage System for Structured Data. In Proc. of the 7th Symposium on Operating System Design and Implementation, (OSDI 2006).
11.M. Datar, N. Immorlica, P. Indyk, and V. Mirrokni Locality-Sensitive Hashing Scheme Based on p-Stable Distributions. In Proc. of the 20th ACM Annual Symposium on Computational Geometry (SOCG 2004).
12.J. Dean, and S. Ghemawat., "MapReduce: Simplified Data Processing on Large Clusters.", In Proc. of 6th Symposium on Operating Systems Design and Implementation (OSDI), San Francisco, 2004.
13.A. Gionis, P. Indyk, and R. Motwani. Similarity Search in High Dimensions via Hashing. In Proc. of the 25th Intl. Conf. on Very Large Data Bases, VLDB(1999).
14.T. Hofmann Latent Semantic Models for Collaborative Filtering In ACM Transactions on Information Systems, 2004, Vol 22(1), pp. 89–115.
15.P. Indyk A Small Approximately Min-Wise Independent Family of Hash Functions. In Proc. 10th Symposium on Discrete Algorithms, SODA (1999).
16.P. Indyk and R. Motwani. Approximate Nearest Neighbor: Towards Removing the Curse of Dimensionality. In Proc. of the 30th Annual ACM Symposium on Theory of Computing, 1998, pp. 604–613.
17.B. Marlin, and R. Zemel The multiple multiplicative factor model for collaborative filtering In ACM Intl. Conf. Proceeding Series, Vol. 69, 2004.
18.R. Motwani and P. Raghavan. Randomized Algorithms. Cambridge University Press, 1985.
19.P. Resnick, N. Iakovou, M. Sushak, P. Bergstrom, and J. Riedl. GroupLens: An Open Architecture for Collaborative Filtering of Netnews, In Proc. of Computer Supported Cooperative Work Conf. , 1994.
20.B. Sarwar, G. Karypis, J. Konstan, and J. Reidl Application of Dimensionality Reduction in Recommender Systems – A Case Study In Proc. of the ACM WebKDD Workshop, 2000.
21.B. Sarwar, G. Karypis, J. Konstan, and J. Reidl Item-based collaborative filtering recommendation algorithms. In Proc. of the 10th Intl. WWW Conf. , (WWW) 2001.
22.G. Shani, R. Brafman, and D. Heckerman, An MDP-Based Recommender System In Proc. of the 18th Conf. Uncertainty in Artificial Intelligence, Aug. 2002.
23.K. Yu, X. Xu, J. Tao, M. Ester, and H. Kriegel Instance Selection Techniques for Memory-Based Collaborative Filtering In Proc. of the Second Siam Intl. Conf. on Data Mining, (SDM) 2002.

Citation

MLA

Das, A. S., et al. “Google News Personalization”. Proceedings of the 16th International Conference on World Wide Web, 2007, pp. 271–80, https://doi.org/10.1145/1242572.1242610.

APA

Das, A. S., Datar, M., Garg, A., & Rajaram, S. (2007). Google news personalization. Proceedings of the 16th International Conference on World Wide Web, 271–280. https://doi.org/10.1145/1242572.1242610

Chicago

Das, A. S., M. Datar, A. Garg, and S. Rajaram. 2007. “Google News Personalization”. Proceedings of the 16th International Conference on World Wide Web, 271–80. https://doi.org/10.1145/1242572.1242610.

Harvard

Das, A.S. et al. (2007) “Google news personalization”, Proceedings of the 16th international conference on World Wide Web. ACM, pp. 271–280. Available at: https://doi.org/10.1145/1242572.1242610.

Vancouver

1. Das AS, Datar M, Garg A, Rajaram S (2007) Google news personalization. In: Proceedings of the 16th international conference on World Wide Web. ACM, pp 271–280

BibTeX

@inproceedings{Das_2007, series={WWW′07}, title={Google news personalization: scalable online collaborative filtering}, url={http://dx.doi.org/10.1145/1242572.1242610}, DOI={10.1145/1242572.1242610}, booktitle={Proceedings of the 16th international conference on World Wide Web}, publisher={ACM}, author={Das, Abhinandan S. and Datar, Mayur and Garg, Ashutosh and Rajaram, Shyam}, year={2007}, month=May, pages={271–280}, collection={WWW′07} }

Metadata:Crossref

Access the Paper

This paper is available from its original source. Click below to access the PDF.

Open PDF

Google news personalization: scalable online collaborative filtering

Abstract

Topics

Keywords

Table of Contents

Knowls

Knowl 1 — MinHash-Based Locality Sensitive Clustering for Binary User Click Histories

Knowl 2 — Parallel Expectation-Maximization for Probabilistic Latent Semantic Indexing via 2D Grid Sharded MapReduce

Knowl 3 — Dynamic Real-Time PLSI Adaptation for High-Churn Itemsets

Knowl 4 — Time-Decayed Item-Item Covisitation Graph for Real-Time Short-Term Recommendations

Knowl 5 — Unified Linear Combination Scoring for Hybrid Multi-Algorithm Recommendations

Knowl 6 — Decoupled Online Serving and Asynchronous Statistics Architecture for Real-Time Recommendations

Knowl 7 — Candidate Generation for Online News Recommendation

Knowl 8 — Precision-Recall Evaluation of MinHash, PLSI, and Correlation on Static Datasets

Knowl 9 — Interlaced A/B Testing Methodology for Position-Unbiased Live Recommendation Evaluation

Knowl 10 — Live Traffic Click-Through Rate Improvement over Popularity Baseline on Google News

References

Citation

BibTeX

Access the Paper