Facebook Newsfeed - Learning Module

Loading content...

0/273

Ranking Algorithms

The Brain Behind the Feed

When you open Facebook, the Newsfeed presents content in an order that feels natural—close friends' life updates appear near the top, relevant news surfaces at the right time, and engaging content seems to find you. This isn't magic or luck; it's the result of one of the most sophisticated ranking systems ever built.

Facebook's ranking algorithm evaluates approximately 1,500 candidate posts for each user, scoring and ordering them in under 50 milliseconds. It processes signals from the social graph, content features, user behavior history, real-time context, and historical engagement patterns to produce a personalized ranking that maximizes value for that specific user at that specific moment.

The core question this system answers:

"If this user could only see N posts today, which N posts would provide the most value?"

Understanding how ranking works is essential for designing feed systems—because the ranking algorithm is not just a component; it's the defining element that determines whether users engage or leave.

What You Will Learn

By the end of this page, you will master the multi-stage ranking funnel architecture, understand key features used in feed ranking models, explore model architectures from logistic regression to deep learning, and learn how to balance engagement optimization with platform health constraints.

The Multi-Stage Ranking Funnel

With billions of posts created daily and thousands of potential candidates per user, running a complex ML model on every candidate is computationally impossible. The solution is a multi-stage ranking funnel that progressively narrows candidates while increasing model complexity.

Think of it as a pyramid: the base handles millions of candidates with simple rules, while the peak handles dozens of finalists with sophisticated models.

Converting Mermaid diagram...

Stage 1: Candidate Generation (100K+ → 10K)

The first stage retrieves all potentially relevant content for a user. This is primarily a retrieval problem, not a ranking problem.

Candidate Sources

•Direct Friends — All posts from users in the friend list (most important source)
•Followed Pages — Posts from liked/followed pages and their recent content
•Groups — Posts from groups the user has joined, weighted by activity level
•Friends of Friends — Public posts from 2nd-degree connections (engagement signals)
•Suggested Content — Algorithm-recommended posts from accounts not followed
•Ads Inventory — Eligible ads based on targeting criteria and budget
•Resurfaced Content — High-value older content the user may have missed

candidate_generation.pseudo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
function generateCandidates(userId, timestamp):
    candidates = []
    
    // Phase 1: Direct network content (highest priority)
    friends = getFriends(userId)  // ~350 avg
    for friend in friends:
        posts = getRecentPosts(friend, since=timestamp - 7_days)
        candidates.extend(posts)
    
    // Phase 2: Page content
    followedPages = getFollowedPages(userId)
    for page in followedPages:
        posts = getRecentPosts(page, since=timestamp - 3_days)
        candidates.extend(posts)
    
    // Phase 3: Group content
    groups = getUserGroups(userId)
    for group in groups:
        posts = getTopGroupPosts(group, limit=50)
        candidates.extend(posts)
    
    // Phase 4: Suggested content (explore)
    suggestedPosts = getExploreContent(userId, limit=1000)
    candidates.extend(suggestedPosts)
    
    // Phase 5: Ads
    eligibleAds = getEligibleAds(userId, context)
    candidates.extend(eligibleAds)
    
    // Deduplication and eligibility filtering
    candidates = deduplicate(candidates)
    candidates = filterByVisibility(candidates, userId)
    candidates = filterSeenContent(candidates, userId)
    
    return candidates  // Typically 50K-100K items

Stage 2: First Pass Ranking (10K → 1K)

This stage applies lightweight filters and a simple scoring model to reduce candidates before expensive feature computation.

First Pass Operations

•Bloom Filter Dedup — Remove previously seen content using probabilistic data structure
•Visibility Enforcement — Filter posts user is not authorized to see
•Recency Filter — Apply time-decay to old content (exponential decay)
•Light ML Model — Logistic regression with ~50 features for coarse ranking
•Hard Policy Filters — Remove content from blocked users, violation flags, etc.

Engineering Insight: Model Cascade Latency

The key insight is latency accumulates. If Stage 1 takes 5ms, Stage 2 takes 10ms, and Stage 3 takes 25ms, you're at 40ms before final selection. Each stage must be ruthlessly optimized. Facebook achieved this through custom ML inference engines (Caffe2, PyTorch Mobile) and pre-computed feature stores.

Stage 3: Main Ranking (1K → 500)

The main ranking stage applies the full-featured ML model. This is where personalization really happens.

Main Ranking Components

•Feature Hydration — Fetch full feature vectors from feature store (user features, content features, context features)
•Deep Learning Inference — Run neural network model for engagement prediction
•Multi-Task Learning — Predict P(like), P(comment), P(share), P(click), P(hide), P(dwell_time) simultaneously
•Value Score Computation — Combine predictions with value weights to compute final score
•Integrity Adjustments — Apply demotions for borderline content, misinformation, etc.

Stage 4: Final Selection (500 → 50)

The final stage transforms ranked scores into an actual feed, incorporating business rules and diversity requirements.

Final Selection Operations

•Diversity Injection — Ensure variety in content types, sources, and topics (prevent filter bubble)
•Friend Content Guarantee — Ensure N% of feed is from close friends regardless of score
•Ad Insertion — Interleave ads at controlled density (typically 1:5 to 1:10 ratio)
•Position Auction — For ad slots, run auction among eligible ads
•Policy Enforcement — Final check for content quality guidelines
•Page Assembly — Construct the final ordered list for rendering

Feature Engineering for Feed Ranking

The ranking model's power comes from its features—the signals that help predict whether a user will engage with content. Feature engineering for feed ranking is an art that combines domain knowledge, statistical analysis, and creative insight.

Features fall into several categories, each capturing different aspects of the ranking decision:

2.1 User Features

Features that describe the user viewing the feed—their history, preferences, and current context.

User Features
Feature Category	Examples	Signal Type
Demographics	Age bucket, gender, locale, timezone	Static
Engagement History	Avg likes/day, comment rate, session length	Aggregated
Content Preferences	Affinity for videos, photos, links, stories	Learned
Social Activity	Friend count, group memberships, page follows	Aggregated
Recency Patterns	Time since last session, typical active hours	Temporal
Device Context	Mobile vs desktop, bandwidth estimate, battery level	Real-time
Topic Interests	Inferred interests from engagement (sports, politics, etc.)	Learned

2.2 Content Features

Features that describe the post being ranked—its type, creator, and engagement signals.

Content Features
Feature Category	Examples	Signal Type
Content Type	Photo, video, link, text-only, live video	Static
Creator Type	Friend, page, group, suggested, ad	Static
Age	Seconds since post creation, decay function output	Temporal
Media Properties	Video length, image count, has thumbnail	Static
Text Features	Word count, has question, has URL, language	NLP
Engagement Stats	Like count, comment count, share count, view count	Aggregated
Velocity	Engagement rate per hour, trending signal	Derived
Creator Performance	Avg engagement on creator's posts	Aggregated
Content Quality	Spam score, clickbait score, originality	ML-derived

2.3 User-Content Interaction Features

The most predictive features capture the relationship between this specific user and this specific content.

Interaction Features (Highest Signal)

•Relationship Strength — How often user engages with this creator (weighted recency)
•Last Interaction — Time since user last engaged with creator's content
•Mutual Friends — Count and engagement strength of shared connections
•Topic Affinity Match — How well content topics match user's inferred interests
•Historical Engagement Pattern — User's past behavior on similar content types from similar creators
•Feed Position History — Where similar content has appeared and engagement at those positions
•Embedding Similarity — Cosine similarity between user and content embeddings

2.4 Context Features

Real-time signals about when and how the user is accessing the feed.

Context Features

•Time of Day — Hour buckets (morning, afternoon, evening, late night)
•Day of Week — Weekend vs weekday behavior differs significantly
•Session Context — First session of day, nth session, session length so far
•Feed Position — How far user has scrolled (engagement drops with depth)
•Previous Interactions This Session — What user has engaged with recently
•Device Type — Mobile users have shorter attention spans
•Network Conditions — Video may be deprioritized on slow connections

feature_vector_example.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# Example feature vector for a single (user, post) pair
feature_vector = {
    # User features
    "user_age_bucket": 3,                    # Categorical: 0-5
    "user_avg_daily_likes": 12.5,            # Continuous
    "user_video_affinity": 0.72,             # Continuous: 0-1
    "user_friend_count": 342,                # Continuous
    "user_session_count_today": 2,           # Continuous
    
    # Content features  
    "content_type": "video",                 # Categorical
    "content_age_seconds": 3600,             # Continuous
    "content_like_count": 156,               # Continuous (log-transformed)
    "content_comment_count": 23,             # Continuous (log-transformed)
    "content_creator_type": "friend",        # Categorical
    "content_video_length_seconds": 45,      # Continuous
    "content_has_text": True,                # Binary
    
    # Interaction features
    "user_creator_interaction_count_30d": 8, # Continuous
    "user_creator_last_engagement_hours": 24,# Continuous
    "topic_affinity_score": 0.85,            # Continuous: 0-1
    "embedding_similarity": 0.62,            # Continuous: -1 to 1
    
    # Context features
    "hour_of_day": 19,                       # Categorical: 0-23
    "is_weekend": False,                     # Binary
    "feed_position": 5,                      # Continuous
    "session_duration_minutes": 3.2,         # Continuous
}
 
# Total: ~200-500 features in production systems

Feature Freshness is Critical

Many features become stale quickly. A post's engagement count from 1 hour ago may be very different from current values. Production systems maintain real-time feature stores (like Facebook's Feature Store) that continuously update aggregated features, trading storage cost for freshness.

Model Architecture

The ranking model has evolved significantly over Facebook's history—from simple edge rank formulas to sophisticated deep learning systems. Understanding this evolution helps illuminate why modern architectures exist.

3.1 Evolution of Ranking Models

Facebook Ranking Model Evolution
Era	Model Type	Key Characteristics
2006-2010	EdgeRank (Heuristic)	Affinity × Weight × Decay formula, manually tuned
2010-2013	Logistic Regression	Linear model with hand-crafted features, 100+ signals
2013-2016	Gradient Boosted Trees	XGBoost/GBM, feature interactions learned automatically
2016-2019	Deep Learning (DNN)	Embeddings, multi-layer networks, learned representations
2019+	Transformer/Attention	Self-attention, cross-feature interactions, unified embeddings

3.2 Modern Deep Learning Architecture

Contemporary feed ranking uses deep neural networks with specialized components for different feature types.

Converting Mermaid diagram...

3.3 Multi-Task Learning

Modern ranking models predict multiple outcomes simultaneously rather than training separate models for each action. This approach improves efficiency and allows the model to learn shared representations.

multi_task_ranking_model.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
class MultiTaskRankingModel(nn.Module):
    def __init__(self, user_dim, content_dim, embed_dim=128):
        super().__init__()
        
        # Embedding layers for sparse features
        self.user_embedding = nn.Embedding(num_users, embed_dim)
        self.content_embedding = nn.Embedding(num_contents, embed_dim)
        self.category_embedding = nn.Embedding(num_categories, embed_dim)
        
        # Shared tower (learns common representations)
        self.shared_tower = nn.Sequential(
            nn.Linear(embed_dim * 3 + dense_features, 512),
            nn.ReLU(),
            nn.BatchNorm1d(512),
            nn.Dropout(0.2),
            nn.Linear(512, 256),
            nn.ReLU(),
        )
        
        # Task-specific towers
        self.like_tower = self._make_tower(256, 64, 1)
        self.comment_tower = self._make_tower(256, 64, 1)
        self.share_tower = self._make_tower(256, 64, 1)
        self.click_tower = self._make_tower(256, 64, 1)
        self.hide_tower = self._make_tower(256, 64, 1)
        self.dwell_tower = self._make_tower(256, 64, 1)  # Regression
    
    def _make_tower(self, in_dim, hidden_dim, out_dim):
        return nn.Sequential(
            nn.Linear(in_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, out_dim),
        )
    
    def forward(self, user_ids, content_ids, category_ids, dense_features):
        # Get embeddings
        user_emb = self.user_embedding(user_ids)
        content_emb = self.content_embedding(content_ids)
        category_emb = self.category_embedding(category_ids)
        
        # Concatenate all features
        x = torch.cat([user_emb, content_emb, category_emb, dense_features], dim=1)
        
        # Shared representation
        shared = self.shared_tower(x)
        
        # Task-specific predictions
        return {
            'p_like': torch.sigmoid(self.like_tower(shared)),
            'p_comment': torch.sigmoid(self.comment_tower(shared)),
            'p_share': torch.sigmoid(self.share_tower(shared)),
            'p_click': torch.sigmoid(self.click_tower(shared)),
            'p_hide': torch.sigmoid(self.hide_tower(shared)),
            'dwell_time': F.softplus(self.dwell_tower(shared)),  # Positive regression
        }

3.4 Value Score Aggregation

The final ranking score combines predicted probabilities with business-defined value weights:

value_score.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
def compute_value_score(predictions, weights):
    """
    Compute final ranking score from multi-task predictions.
    
    Value = Σ(P(action_i) × value_weight_i)
    
    Weights are tuned based on business objectives.
    """
    value_weights = {
        'like': 1.0,         # Baseline
        'comment': 5.0,      # Meaningful interaction (higher weight)
        'share': 10.0,       # Viral potential (highest positive weight)
        'click': 2.0,        # Content consumption
        'hide': -10.0,       # Negative signal (penalize)
        'dwell': 0.1,        # Per-second weight for watch time
    }
    
    score = (
        predictions['p_like'] * value_weights['like'] +
        predictions['p_comment'] * value_weights['comment'] +
        predictions['p_share'] * value_weights['share'] +
        predictions['p_click'] * value_weights['click'] +
        predictions['p_hide'] * value_weights['hide'] +
        predictions['dwell_time'] * value_weights['dwell']
    )
    
    return score
 
# These weights are the "dials" that control feed behavior
# Increasing comment weight → more discussion-oriented content
# Increasing share weight → more viral content
# Decreasing dwell weight → less video, more quick content

The Power of Weight Tuning

Value weights are arguably more important than model architecture. Facebook's shift toward 'Meaningful Social Interactions' was implemented primarily by increasing weights on comments and shares versus likes. The same model, different weights → fundamentally different feed character.

Training and Evaluation

Training ranking models at Facebook's scale presents unique challenges: massive data volumes, continuously shifting distributions, and the need for real-time adaptation.

4.1 Training Data Generation

Ranking models are trained on logged user interactions—but this creates inherent biases.

Training Data Pipeline

•Impression Logging — Record every post shown to every user with position
•Engagement Logging — Record all user actions (like, comment, hide, dwell time)
•Feature Snapshot — Capture feature values at impression time (avoid leakage)
•Negative Sampling — Include non-engaged impressions as negative examples
•Label Delay — Wait sufficient time for delayed conversions (24h for comments)

Position Bias Problem

Content at position 1 gets clicked more than content at position 10—not necessarily because it's better, but because it's seen. Naive training reinforces this bias: high-position content appears better, gets ranked higher, creating a feedback loop. Solutions include inverse propensity weighting and position-aware models.

4.2 Offline Evaluation Metrics

Ranking Evaluation Metrics
Metric	Definition	Use Case
AUC-ROC	Area under receiver operating curve	Binary classification quality
NDCG	Normalized discounted cumulative gain	Ranking quality (top matters more)
MAP	Mean average precision	Precision at various cutoffs
Recall@K	Fraction of relevant items in top K	Coverage of good content
LogLoss	Negative log-likelihood	Probability calibration
MSE	Mean squared error (for dwell time)	Regression accuracy

4.3 Online Evaluation (A/B Testing)

Offline metrics don't fully capture user experience. Online A/B tests measure real impact.

Online Metrics (North Stars)

•Daily Active Users (DAU) — Ultimate engagement measure
•Session Duration — Time spent in app per session
•Sessions per Day — How often users return
•Engagement Rate — Actions per impression
•MSI (Meaningful Social Interactions) — Comments + shares specifically
•Content Production — Do users create more content?
•User Satisfaction Surveys — Explicit feedback on feed quality

4.4 Continuous Training Pipeline

continuous_training.pseudo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Facebook trains ranking models continuously, not just periodically
 
Training Pipeline:
1. Stream impression/engagement logs (billions/day)
2. Join features from feature store (point-in-time features)
3. Generate training examples with labels
4. Train model on sliding window (7-14 days of data)
5. Validate on held-out data
6. Shadow score production traffic (no serving)
7. Compare metrics to current production model
8. If improved: Gradual rollout (1% → 5% → 25% → 100%)
9. Monitor online metrics during rollout
10. Rollback if degradation detected
 
Cadence:
- Model retraining: Daily or continuous
- Feature deployment: Weekly
- Architecture changes: Monthly (with extensive testing)

Integrity and Safety in Ranking

Pure engagement optimization leads to problematic outcomes: misinformation spreads because it's engaging, outrage drives clicks, and sensationalism wins. Modern feed ranking must incorporate integrity signals that penalize harmful content even when it would drive engagement.

5.1 Integrity Interventions

Ranking Penalties

•Misinformation Demotion — Content flagged by fact-checkers receives 80-95% reduced distribution
•Borderline Content Reduction — Content that nearly violates policies is demoted (sensationalism, clickbait)
•Repeat Offender Penalty — Creators with violation history receive blanket demotion
•Low-Quality Signal — Scraped content, spam-like patterns, engagement bait
•Civic Integrity — Political content from unverified sources receives additional scrutiny

5.2 Classifier Integration

integrity_score.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
def compute_integrity_adjusted_score(base_score, content):
    """
    Apply integrity adjustments to base ranking score.
    Integrity scores are computed by specialized classifiers.
    """
    adjustments = []
    
    # Misinformation classifier
    misinfo_score = misinfo_classifier.predict(content)
    if misinfo_score > 0.8:  # High confidence misinformation
        adjustments.append(("misinfo_hard", 0.05))  # 95% reduction
    elif misinfo_score > 0.5:  # Probable misinformation
        adjustments.append(("misinfo_soft", 0.20))  # 80% reduction
    
    # Clickbait classifier
    clickbait_score = clickbait_classifier.predict(content)
    if clickbait_score > 0.7:
        adjustments.append(("clickbait", 0.50))  # 50% reduction
    
    # Violence/graphic content classifier
    violence_score = violence_classifier.predict(content)
    if violence_score > 0.9:
        adjustments.append(("violence", 0.0))  # 100% reduction (remove)
    
    # Hate speech borderline detector
    hate_borderline = hate_borderline_classifier.predict(content)
    if hate_borderline > 0.6:
        adjustments.append(("hate_borderline", 0.30))  # 70% reduction
    
    # Apply multiplicative adjustments
    final_multiplier = 1.0
    for name, multiplier in adjustments:
        final_multiplier *= multiplier
        log_adjustment(content.id, name, multiplier)
    
    return base_score * final_multiplier

5.3 Balancing Engagement vs Integrity

Engagement Optimization

•Maximize time on platform
•Increase return visits
•Drive ad revenue
•Favor viral content
•Optimize for clicks/reactions

Integrity Optimization

•Reduce misinformation
•Prevent harassment
•Avoid filter bubbles
•Protect vulnerable users
•Maintain advertiser safety

The Integrity Tax

Facebook has publicly acknowledged that integrity interventions reduce engagement metrics by measurable percentages. This is intentional—accepting short-term engagement loss for long-term platform health and public trust. This trade-off is a business decision, not just an engineering one.

Summary: Ranking Algorithms

We've explored the sophisticated ranking systems that power Facebook's personalized feed. Let's consolidate the key concepts:

Key Takeaways

•Multi-stage funnel is essential — 100K candidates cannot be scored with complex models; progressive filtering with increasing model complexity is the pattern
•Features make the model — User features, content features, interaction features, and context features combine to capture ranking signals
•Multi-task learning is standard — Single model predicts multiple outcomes (like, comment, share, hide), combined with value weights
•Value weights are tunable dials — Same model, different weights → different feed character; business priorities encoded here
•Training is continuous — Daily retraining on fresh data, with careful handling of position bias and delayed labels
•Integrity constrains engagement — Modern feeds penalize harmful content even at engagement cost; classifiers integrated into scoring

What's Next:

With ranking algorithms understood, the next page explores Content Aggregation—how content is collected, indexed, and made available for ranking across Facebook's distributed infrastructure.

Page Complete

You now understand the ML systems that power feed personalization. The multi-stage funnel, feature engineering, model architecture, and integrity integration form the core of how Facebook decides what you see and when.

Ranking Algorithms

The Brain Behind the Feed

The core question this system answers:

"If this user could only see N posts today, which N posts would provide the most value?"

What You Will Learn

The Multi-Stage Ranking Funnel

Think of it as a pyramid: the base handles millions of candidates with simple rules, while the peak handles dozens of finalists with sophisticated models.

Converting Mermaid diagram...

Stage 1: Candidate Generation (100K+ → 10K)

The first stage retrieves all potentially relevant content for a user. This is primarily a retrieval problem, not a ranking problem.

Candidate Sources

•Direct Friends — All posts from users in the friend list (most important source)
•Followed Pages — Posts from liked/followed pages and their recent content
•Groups — Posts from groups the user has joined, weighted by activity level
•Friends of Friends — Public posts from 2nd-degree connections (engagement signals)
•Suggested Content — Algorithm-recommended posts from accounts not followed
•Ads Inventory — Eligible ads based on targeting criteria and budget
•Resurfaced Content — High-value older content the user may have missed

candidate_generation.pseudo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
function generateCandidates(userId, timestamp):
    candidates = []
    
    // Phase 1: Direct network content (highest priority)
    friends = getFriends(userId)  // ~350 avg
    for friend in friends:
        posts = getRecentPosts(friend, since=timestamp - 7_days)
        candidates.extend(posts)
    
    // Phase 2: Page content
    followedPages = getFollowedPages(userId)
    for page in followedPages:
        posts = getRecentPosts(page, since=timestamp - 3_days)
        candidates.extend(posts)
    
    // Phase 3: Group content
    groups = getUserGroups(userId)
    for group in groups:
        posts = getTopGroupPosts(group, limit=50)
        candidates.extend(posts)
    
    // Phase 4: Suggested content (explore)
    suggestedPosts = getExploreContent(userId, limit=1000)
    candidates.extend(suggestedPosts)
    
    // Phase 5: Ads
    eligibleAds = getEligibleAds(userId, context)
    candidates.extend(eligibleAds)
    
    // Deduplication and eligibility filtering
    candidates = deduplicate(candidates)
    candidates = filterByVisibility(candidates, userId)
    candidates = filterSeenContent(candidates, userId)
    
    return candidates  // Typically 50K-100K items

Stage 2: First Pass Ranking (10K → 1K)

This stage applies lightweight filters and a simple scoring model to reduce candidates before expensive feature computation.

First Pass Operations

•Bloom Filter Dedup — Remove previously seen content using probabilistic data structure
•Visibility Enforcement — Filter posts user is not authorized to see
•Recency Filter — Apply time-decay to old content (exponential decay)
•Light ML Model — Logistic regression with ~50 features for coarse ranking
•Hard Policy Filters — Remove content from blocked users, violation flags, etc.

Engineering Insight: Model Cascade Latency

Stage 3: Main Ranking (1K → 500)

The main ranking stage applies the full-featured ML model. This is where personalization really happens.

Main Ranking Components

•Feature Hydration — Fetch full feature vectors from feature store (user features, content features, context features)
•Deep Learning Inference — Run neural network model for engagement prediction
•Multi-Task Learning — Predict P(like), P(comment), P(share), P(click), P(hide), P(dwell_time) simultaneously
•Value Score Computation — Combine predictions with value weights to compute final score
•Integrity Adjustments — Apply demotions for borderline content, misinformation, etc.

Stage 4: Final Selection (500 → 50)

The final stage transforms ranked scores into an actual feed, incorporating business rules and diversity requirements.

Final Selection Operations

•Diversity Injection — Ensure variety in content types, sources, and topics (prevent filter bubble)
•Friend Content Guarantee — Ensure N% of feed is from close friends regardless of score
•Ad Insertion — Interleave ads at controlled density (typically 1:5 to 1:10 ratio)
•Position Auction — For ad slots, run auction among eligible ads
•Policy Enforcement — Final check for content quality guidelines
•Page Assembly — Construct the final ordered list for rendering

Feature Engineering for Feed Ranking

Features fall into several categories, each capturing different aspects of the ranking decision:

2.1 User Features

Features that describe the user viewing the feed—their history, preferences, and current context.

User Features
Feature Category	Examples	Signal Type
Demographics	Age bucket, gender, locale, timezone	Static
Engagement History	Avg likes/day, comment rate, session length	Aggregated
Content Preferences	Affinity for videos, photos, links, stories	Learned
Social Activity	Friend count, group memberships, page follows	Aggregated
Recency Patterns	Time since last session, typical active hours	Temporal
Device Context	Mobile vs desktop, bandwidth estimate, battery level	Real-time
Topic Interests	Inferred interests from engagement (sports, politics, etc.)	Learned

2.2 Content Features

Features that describe the post being ranked—its type, creator, and engagement signals.

Content Features
Feature Category	Examples	Signal Type
Content Type	Photo, video, link, text-only, live video	Static
Creator Type	Friend, page, group, suggested, ad	Static
Age	Seconds since post creation, decay function output	Temporal
Media Properties	Video length, image count, has thumbnail	Static
Text Features	Word count, has question, has URL, language	NLP
Engagement Stats	Like count, comment count, share count, view count	Aggregated
Velocity	Engagement rate per hour, trending signal	Derived
Creator Performance	Avg engagement on creator's posts	Aggregated
Content Quality	Spam score, clickbait score, originality	ML-derived

2.3 User-Content Interaction Features

The most predictive features capture the relationship between this specific user and this specific content.

Interaction Features (Highest Signal)

•Relationship Strength — How often user engages with this creator (weighted recency)
•Last Interaction — Time since user last engaged with creator's content
•Mutual Friends — Count and engagement strength of shared connections
•Topic Affinity Match — How well content topics match user's inferred interests
•Historical Engagement Pattern — User's past behavior on similar content types from similar creators
•Feed Position History — Where similar content has appeared and engagement at those positions
•Embedding Similarity — Cosine similarity between user and content embeddings

2.4 Context Features

Real-time signals about when and how the user is accessing the feed.

Context Features

•Time of Day — Hour buckets (morning, afternoon, evening, late night)
•Day of Week — Weekend vs weekday behavior differs significantly
•Session Context — First session of day, nth session, session length so far
•Feed Position — How far user has scrolled (engagement drops with depth)
•Previous Interactions This Session — What user has engaged with recently
•Device Type — Mobile users have shorter attention spans
•Network Conditions — Video may be deprioritized on slow connections

feature_vector_example.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# Example feature vector for a single (user, post) pair
feature_vector = {
    # User features
    "user_age_bucket": 3,                    # Categorical: 0-5
    "user_avg_daily_likes": 12.5,            # Continuous
    "user_video_affinity": 0.72,             # Continuous: 0-1
    "user_friend_count": 342,                # Continuous
    "user_session_count_today": 2,           # Continuous
    
    # Content features  
    "content_type": "video",                 # Categorical
    "content_age_seconds": 3600,             # Continuous
    "content_like_count": 156,               # Continuous (log-transformed)
    "content_comment_count": 23,             # Continuous (log-transformed)
    "content_creator_type": "friend",        # Categorical
    "content_video_length_seconds": 45,      # Continuous
    "content_has_text": True,                # Binary
    
    # Interaction features
    "user_creator_interaction_count_30d": 8, # Continuous
    "user_creator_last_engagement_hours": 24,# Continuous
    "topic_affinity_score": 0.85,            # Continuous: 0-1
    "embedding_similarity": 0.62,            # Continuous: -1 to 1
    
    # Context features
    "hour_of_day": 19,                       # Categorical: 0-23
    "is_weekend": False,                     # Binary
    "feed_position": 5,                      # Continuous
    "session_duration_minutes": 3.2,         # Continuous
}
 
# Total: ~200-500 features in production systems

Feature Freshness is Critical

Model Architecture

3.1 Evolution of Ranking Models

Facebook Ranking Model Evolution
Era	Model Type	Key Characteristics
2006-2010	EdgeRank (Heuristic)	Affinity × Weight × Decay formula, manually tuned
2010-2013	Logistic Regression	Linear model with hand-crafted features, 100+ signals
2013-2016	Gradient Boosted Trees	XGBoost/GBM, feature interactions learned automatically
2016-2019	Deep Learning (DNN)	Embeddings, multi-layer networks, learned representations
2019+	Transformer/Attention	Self-attention, cross-feature interactions, unified embeddings

3.2 Modern Deep Learning Architecture

Contemporary feed ranking uses deep neural networks with specialized components for different feature types.

Converting Mermaid diagram...

3.3 Multi-Task Learning

multi_task_ranking_model.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
class MultiTaskRankingModel(nn.Module):
    def __init__(self, user_dim, content_dim, embed_dim=128):
        super().__init__()
        
        # Embedding layers for sparse features
        self.user_embedding = nn.Embedding(num_users, embed_dim)
        self.content_embedding = nn.Embedding(num_contents, embed_dim)
        self.category_embedding = nn.Embedding(num_categories, embed_dim)
        
        # Shared tower (learns common representations)
        self.shared_tower = nn.Sequential(
            nn.Linear(embed_dim * 3 + dense_features, 512),
            nn.ReLU(),
            nn.BatchNorm1d(512),
            nn.Dropout(0.2),
            nn.Linear(512, 256),
            nn.ReLU(),
        )
        
        # Task-specific towers
        self.like_tower = self._make_tower(256, 64, 1)
        self.comment_tower = self._make_tower(256, 64, 1)
        self.share_tower = self._make_tower(256, 64, 1)
        self.click_tower = self._make_tower(256, 64, 1)
        self.hide_tower = self._make_tower(256, 64, 1)
        self.dwell_tower = self._make_tower(256, 64, 1)  # Regression
    
    def _make_tower(self, in_dim, hidden_dim, out_dim):
        return nn.Sequential(
            nn.Linear(in_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, out_dim),
        )
    
    def forward(self, user_ids, content_ids, category_ids, dense_features):
        # Get embeddings
        user_emb = self.user_embedding(user_ids)
        content_emb = self.content_embedding(content_ids)
        category_emb = self.category_embedding(category_ids)
        
        # Concatenate all features
        x = torch.cat([user_emb, content_emb, category_emb, dense_features], dim=1)
        
        # Shared representation
        shared = self.shared_tower(x)
        
        # Task-specific predictions
        return {
            'p_like': torch.sigmoid(self.like_tower(shared)),
            'p_comment': torch.sigmoid(self.comment_tower(shared)),
            'p_share': torch.sigmoid(self.share_tower(shared)),
            'p_click': torch.sigmoid(self.click_tower(shared)),
            'p_hide': torch.sigmoid(self.hide_tower(shared)),
            'dwell_time': F.softplus(self.dwell_tower(shared)),  # Positive regression
        }

3.4 Value Score Aggregation

The final ranking score combines predicted probabilities with business-defined value weights:

value_score.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
def compute_value_score(predictions, weights):
    """
    Compute final ranking score from multi-task predictions.
    
    Value = Σ(P(action_i) × value_weight_i)
    
    Weights are tuned based on business objectives.
    """
    value_weights = {
        'like': 1.0,         # Baseline
        'comment': 5.0,      # Meaningful interaction (higher weight)
        'share': 10.0,       # Viral potential (highest positive weight)
        'click': 2.0,        # Content consumption
        'hide': -10.0,       # Negative signal (penalize)
        'dwell': 0.1,        # Per-second weight for watch time
    }
    
    score = (
        predictions['p_like'] * value_weights['like'] +
        predictions['p_comment'] * value_weights['comment'] +
        predictions['p_share'] * value_weights['share'] +
        predictions['p_click'] * value_weights['click'] +
        predictions['p_hide'] * value_weights['hide'] +
        predictions['dwell_time'] * value_weights['dwell']
    )
    
    return score
 
# These weights are the "dials" that control feed behavior
# Increasing comment weight → more discussion-oriented content
# Increasing share weight → more viral content
# Decreasing dwell weight → less video, more quick content

The Power of Weight Tuning

Training and Evaluation

Training ranking models at Facebook's scale presents unique challenges: massive data volumes, continuously shifting distributions, and the need for real-time adaptation.

4.1 Training Data Generation

Ranking models are trained on logged user interactions—but this creates inherent biases.

Training Data Pipeline

•Impression Logging — Record every post shown to every user with position
•Engagement Logging — Record all user actions (like, comment, hide, dwell time)
•Feature Snapshot — Capture feature values at impression time (avoid leakage)
•Negative Sampling — Include non-engaged impressions as negative examples
•Label Delay — Wait sufficient time for delayed conversions (24h for comments)

Position Bias Problem

4.2 Offline Evaluation Metrics

Ranking Evaluation Metrics
Metric	Definition	Use Case
AUC-ROC	Area under receiver operating curve	Binary classification quality
NDCG	Normalized discounted cumulative gain	Ranking quality (top matters more)
MAP	Mean average precision	Precision at various cutoffs
Recall@K	Fraction of relevant items in top K	Coverage of good content
LogLoss	Negative log-likelihood	Probability calibration
MSE	Mean squared error (for dwell time)	Regression accuracy

4.3 Online Evaluation (A/B Testing)

Offline metrics don't fully capture user experience. Online A/B tests measure real impact.

Online Metrics (North Stars)

•Daily Active Users (DAU) — Ultimate engagement measure
•Session Duration — Time spent in app per session
•Sessions per Day — How often users return
•Engagement Rate — Actions per impression
•MSI (Meaningful Social Interactions) — Comments + shares specifically
•Content Production — Do users create more content?
•User Satisfaction Surveys — Explicit feedback on feed quality

4.4 Continuous Training Pipeline

continuous_training.pseudo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Facebook trains ranking models continuously, not just periodically
 
Training Pipeline:
1. Stream impression/engagement logs (billions/day)
2. Join features from feature store (point-in-time features)
3. Generate training examples with labels
4. Train model on sliding window (7-14 days of data)
5. Validate on held-out data
6. Shadow score production traffic (no serving)
7. Compare metrics to current production model
8. If improved: Gradual rollout (1% → 5% → 25% → 100%)
9. Monitor online metrics during rollout
10. Rollback if degradation detected
 
Cadence:
- Model retraining: Daily or continuous
- Feature deployment: Weekly
- Architecture changes: Monthly (with extensive testing)

Integrity and Safety in Ranking

5.1 Integrity Interventions

Ranking Penalties

•Misinformation Demotion — Content flagged by fact-checkers receives 80-95% reduced distribution
•Borderline Content Reduction — Content that nearly violates policies is demoted (sensationalism, clickbait)
•Repeat Offender Penalty — Creators with violation history receive blanket demotion
•Low-Quality Signal — Scraped content, spam-like patterns, engagement bait
•Civic Integrity — Political content from unverified sources receives additional scrutiny

5.2 Classifier Integration

integrity_score.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
def compute_integrity_adjusted_score(base_score, content):
    """
    Apply integrity adjustments to base ranking score.
    Integrity scores are computed by specialized classifiers.
    """
    adjustments = []
    
    # Misinformation classifier
    misinfo_score = misinfo_classifier.predict(content)
    if misinfo_score > 0.8:  # High confidence misinformation
        adjustments.append(("misinfo_hard", 0.05))  # 95% reduction
    elif misinfo_score > 0.5:  # Probable misinformation
        adjustments.append(("misinfo_soft", 0.20))  # 80% reduction
    
    # Clickbait classifier
    clickbait_score = clickbait_classifier.predict(content)
    if clickbait_score > 0.7:
        adjustments.append(("clickbait", 0.50))  # 50% reduction
    
    # Violence/graphic content classifier
    violence_score = violence_classifier.predict(content)
    if violence_score > 0.9:
        adjustments.append(("violence", 0.0))  # 100% reduction (remove)
    
    # Hate speech borderline detector
    hate_borderline = hate_borderline_classifier.predict(content)
    if hate_borderline > 0.6:
        adjustments.append(("hate_borderline", 0.30))  # 70% reduction
    
    # Apply multiplicative adjustments
    final_multiplier = 1.0
    for name, multiplier in adjustments:
        final_multiplier *= multiplier
        log_adjustment(content.id, name, multiplier)
    
    return base_score * final_multiplier

5.3 Balancing Engagement vs Integrity

Engagement Optimization

•Maximize time on platform
•Increase return visits
•Drive ad revenue
•Favor viral content
•Optimize for clicks/reactions

Integrity Optimization

•Reduce misinformation
•Prevent harassment
•Avoid filter bubbles
•Protect vulnerable users
•Maintain advertiser safety

The Integrity Tax

Summary: Ranking Algorithms

We've explored the sophisticated ranking systems that power Facebook's personalized feed. Let's consolidate the key concepts:

Key Takeaways

•Multi-stage funnel is essential — 100K candidates cannot be scored with complex models; progressive filtering with increasing model complexity is the pattern
•Features make the model — User features, content features, interaction features, and context features combine to capture ranking signals
•Multi-task learning is standard — Single model predicts multiple outcomes (like, comment, share, hide), combined with value weights
•Value weights are tunable dials — Same model, different weights → different feed character; business priorities encoded here
•Training is continuous — Daily retraining on fresh data, with careful handling of position bias and delayed labels
•Integrity constrains engagement — Modern feeds penalize harmful content even at engagement cost; classifiers integrated into scoring

What's Next:

With ranking algorithms understood, the next page explores Content Aggregation—how content is collected, indexed, and made available for ranking across Facebook's distributed infrastructure.

Page Complete