Contents ↑

• The data
• Matrix factorization
  • Interpreting the parameters
  • Why rank one?
  • The choice of norm
  • Learning the factorization
• Doing it ourselves
  • One battle after another
• Diamond plots
• Further tweaks
  • Diamond regularization
  • Rater helpfulness

The bridging algorithm behind Community Notes

There’s a fascinating article from last year in Asterisk magazine about how the Community Notes feature on Twitter/X came to be. The article focuses more on the iterative design and rollout process behind Community Notes—formerly known by the wonderful name Birdwatch—than on the “bridging” algorithm that Twitter/X uses to evaluate notes. Thankfully, an October 2022 paper published by the feature’s designers (and linked in the article) gives more details.

The bridging algorithm is quite clever, and I found both certain choices that the designers made and the nature of their results to be non-intuitive. I’ll go through the details of the algorithm, then talk a little bit about what the results mean. I’ll also include some details about matrix factorization that aren’t relevant to the bridging algorithm implementation, but were useful to me in thinking about why the authors chose the minimization algorithm they did.

The data

The only data the bridging algorithm uses are ratings assigned by users to prospective community notes. Per the paper, users have three options for ratings: “helpful”, “somewhat helpful”, or “not helpful”. A key perspective behind the bridging algorithm is to view this data as a matrix $R = (r_{u,n})$ indexed by user $u$ and note $n$; this is a standard approach in the recommender-systems literature. For the bridging algorithm, the entry $r_{u,n}$ takes the value $0$ for a “not helpful” rating, $1$ for a “helpful” rating, and is null if the user has not rated the note.

The matrix $R$ has a couple features worth noting:

• $R$ is massive: at all-of-Twitter/X scale, we should imagine the number of users $U$ satisfying $U \ge 10^7$ and maybe $U \ge 10^8$. It’s less clear how big the number of notes $N$ is in practice, since not all tweets get prospective notes attached. In the paper’s example, $U = 7544$ and $N = 15368$; in the daily data snapshots, we have $U \approx 2\times 10^6$ and $N \approx 2 \times 10^6$.

• $R$ is very sparse: most notes have only a handful of ratings, and most users rate only a few notes (in a given time period). Hence most entries of $R$ are null. In the paper’s example, there are only $P = 149888$ user-note pairs with non-null entries of $R$, so the density of nonzero entries in $R$ is $$\frac{P}{UN} \approx 1.3\times10^{-3}.$$ This is about 25 times denser than the ratings matrices in the daily data snapshots, which has around 200 million nonzero entries.

Matrix factorization

The key idea behind the bridging algorithm is to try and approximate the rating matrix $R = (r_{u,n})$ as $$\hat{r}_{u,n} \approx \mu + i_u + j_n + f_u g_n$$ where $\mu$ is a scalar, $i$ and $f$ are vectors indexed by user, and $j$ and $g$ are vectors indexed by note. This is simply a rank-one approximate matrix factorization of $R$ together with certain intercept terms. There are $2(U+N)+1$ free parameters.

Interpreting the parameters

Let’s go through each of the five parameters ($\mu, f, g, i, j$) and try to understand how various features of the data are going to affect each of them.

• The global intercept scalar $\mu$ will simply reflect how likely a rating is to be helpful. In the example data, around 62% of the 149,888 ratings are helpful, so we should have $\mu \approx 0.62$.

• The note content vector $g$ measures where a note falls on the “principal component” of the rating data. What is this principal component? Let’s explain with a thought experiment.
  Suppose that users fall into two groups: dog lovers and cat lovers. Also suppose that all dog lovers rate a note helpful if and only if it contains at least one picture of a dog, and likewise for cat lovers and pictures of cats. Then the note content vector will roughly measure “does this note contain pictures of dogs or pictures of cats?”.
  In the real world, it’s (as always) the left/right partisan axis.

• The user affinity vector $f$ measures how a user’s rating of a note depends on the note’s content. Continuing the above thought experiment, $f_u$ will measure whether a user is a dog lover or a cat lover.

• The user intercept vector $i$ will reflect how likely a given user is to rate a note as helpful, above the $\mu$ baseline and independent of the user’s affinity for the note’s content (as measured by the $f_u g_n$ value). In our thought experiment, all $i_u$ values will be approximately zero, because a user’s rating depends only on the note’s content and their affinity for it.
  The reader is invited to construct a thought experiment where users can be dog lovers/haters and cat lovers/haters independently so that the user-intercept values are nonzero.

• The note intercept vector $j$ will reflect how likely a given note is to receive a “helpful” rating, again above the $\mu$ baseline and independent of the user’s affinity for the note’s content. In our thought experiment, $j$ will be positive if a note contains both dog and cat pictures, and negative if a note contains neither. (The values of $j$ for dog-only/cat-only posts depend on the relative size of the dog-loving/cat-loving audiences.)

Note that $\mu, i, j$ all have natural interpretations along the “helpfulness” axis, whereas $f$ and $g$ don’t in and of themselves. This is because we can multiply every $f_u$ by some global scalar $c$ and divide each $g_n$ by $c$ without affecting the quality of our approximation.

Now, in the recommender-system setting, we want to find items $n$ such that $j_n$ is large and the item content $g_n$ aligns with the user affinity $f_u$. But if instead we want to evaluate a note’s usefulness in the Community Notes setting, the scalar value $j_n$ is the only thing we should focus on. If we want to show all users, no matter their position on the petisan axis, notes that they’ll find helpful, we should just show notes with both dog and cat pictures: that is, notes with positive $j_n$ values. And this is exactly what Community Notes does: in order to be displayed to all users, notes must have a note intercept value of at least $0.4$ in the system described in the paper. More generally, notes with intercept values below $-0.08$ are categorized as “unhelpful”, notes with intercepts above $0.4$ are categorized as “helpful”, and notes with intercepts between $-0.08$ and $0.4$ are categorized as “needs more ratings”.

Why rank one?

It is possible to make the scalars $f_u$ and $g_n$ defined above vectors instead, provided we replace multiplication by taking the dot product. This makes $f$ a $u×k$ matrix and $g$ a $k×n$ matrix (the vector case above being $k=1$), and takes the total number of parameters from $2(U+N)+1$ to $(k+1)(U+N)+1$. This is the traditional approach in the recommender-systems literature, where we can imagine distinct axes such as “is this a horror movie?” or “does this movie pass the Bechdel test?”.

We should expect that adding these parameters (called factor dimensions) improves the fit, and the authors note that taking $k=2$ modestly improved RMSE on held-out samples from 0.076 to 0.073. Unfortunately, they also note that the additional factor dimension “reduced interpretability and replicability”, and hence they used only one factor dimension in the system evaluated in the paper. This isn’t terribly surprising, since in the paper’s example we are quite close to the overparametrized regime: taking even $k = 6$ would yield more free parameters than data points. (Another point in favor of taking $k=1$ is that higher $k$ make the diamond plots below more complicated.)

The choice of norm

We also need to decide how we’re going to evaluate the quality of a proposed matrix factorization. The authors use the objective function $$\frac{1}{P}\sum_{r_{u,n}} \left(r_{u,n} - \hat{r}_{u,n}\right)^2 +\lambda_i\left(\mu^2 + \frac{1}{U}\left\|i\right\|^2 + \frac{1}{N}\left\|j\right\|^2\right) + \lambda_f\left(\frac{1}{U}\left\|f\right\|^2 + \frac{1}{N}\left\|g\right\|^2\right)$$

with $λ_i = 0.15$ and $λ_f = 0.03$. This is a pretty straightforward choice: it’s basically the first thing you’d write down, and it’s got some nice properties. Let’s go through the three terms in order.

• The first term $\frac{1}{P}\sum_{r_{u,n}} \left(r_{u,n} - \hat{r}_{u,n}\right)^2$ is the average $L^2$/Frobenius norm of our approximation, with the key detail that we only evaluate this at the $P$ user-note pairs where we actually have data since most of $R$ is null. This will heavily penalize large prediction errors.

• The second term $\lambda_i\left(\mu^2 + \frac{1}{U}\left\|i\right\|^2 + \frac{1}{N}\left\|j\right\|^2\right)$ is a regularization on the three intercepts: the global intercept $\mu$, the user intercept vector $i$, and the note intercept vector $j$. I’m not quite sure why we need to regularize $\mu$; my instinct is that we’d get a really good estimate for the single parameter $\mu$ without the regularization term since we have so much data.
  On the other hand, because we have so much data I also suspect that the regularization on $\mu$ here won’t matter very much.
  The $i$ and $j$ intercepts make somewhat more sense: because $R$ is so sparse, most users rate only a handful of notes and most notes are rated by only a handful of users, so we want to make sure we’re confident in large nonzero values (which will control deviations of predictions from the baseline $\mu$ value).

• The third term $\lambda_f\left(\frac{1}{U}\left\|f\right\|^2 + \frac{1}{N}\left\|g\right\|^2\right)$ is a regularization on the factor vectors. Note that it wouldn’t really matter if we had different penalties on $f$ and $g$, since the rescaling discussion above (i.e., the global multiplication by $c$) would let us transfer the penalty between $f$ and $g$. The justification for the regularization terms here is the same as for $i$ and $j$ above.

It’s not completely clear to me what the intuition behind the precise values of $\lambda_i$ and $\lambda_f$ is, or if there’s any intuition there at all. The authors give a good explanation for why $\lambda_i > \lambda_f$: namely, that the preference for good precision (few false positives for good Community Notes) is much stronger than the preference for good recall (few false negatives). Part of the logic here is that there are other ways to address poor recall, such as deliberately seeking out additional ratings on prospective Community Notes with $j_n < 0.4$.

Learning the factorization

So now that we know what we’re looking for, and why we’re looking for it, we only need address how we’re going to find good values for our parameters $\mu, f, g, i, j$. If it were just the Frobenius term and $R$ were dense, we could use the rank-1 singular value decomposition. Unfortunately, the regularization terms make a linear-algebraic solution rather more challenging. So, following a tradition dating back (at least) to Simon Funk’s work on the Netflix Prize dataset, we just do gradient descent. After all, gradient descent on the Frobenius norm will actually find arbitrary-rank SVD approximations of a matrix, so we should expect it to do fine here. But there are a few fun insights in store for us about how to actually do the gradient descent!

Doing it ourselves

Twitter/X makes daily snapshots of Community Notes data available for download, so we can try and replicate these results. We’re going to deliberately skip a few tweaks that we discuss below, and we’re not going to spend much time optimizing gradient-descent hyperparameters, so we shouldn’t necessarily expect to get results anywhere near those of the paper. On the other hand, we have a couple orders of magnitude more data: recent snapshots contain 150M+ ratings by 1.5M+ users on 1.5M+ notes.

I slapped together some code that gets ratings files, drops all the data we don’t need to do matrix factorization, filters out notes/raters with too few ratings, and then runs the matrix factorization algorithm. You can find it

One battle after another

I hit pitfall after pitfall when setting this up. I started off by not reading the code and doing a pretty vanilla ML setup: Adam, learning rate around $3 \times 10^{-4}$, and batching. Given the form of the loss function above, we should expect initial loss on the order of 0.25-0.5, simply because guessing 0.5 for $\mu$ and something around zero for everything else is a pretty decent starting point. Indeed, the pre-epoch-one losses were in this neighborhood. But the post-epoch-one losses were enormous: often greater than 10. So what went wrong?

This is a good puzzle, so feel free to stop and think about it for a bit. If you want, here’s a hint: it’s not momentum-related, as the same phenomenon occurs if we switch from Adam to SGD.

The answer turns out to be the batching. If we step our optimizer every 100,000 ratings or so, it’s very likely that a number of notes or raters only appear once in that ratings batch. So even with the regularization terms, the optimizer will

Diamond plots

Further tweaks

Two further tweaks are worth mentioning: diamond regularization and filtering for rater helpfulness.

Diamond regularization

While not mentioned in the paper, diamond regularization is another tool to help ensure that only Community Notes with cross-factor consensus have good intercept. The idea is to add the term $$\lambda_d \frac{1}{N} \sum_n \left|j_ng_n\right|$$ to our loss functional; a suggested value is $\lambda_d = 0.75$. This term penalizes notes that have both a large note content coefficient (in either direction) and a large note intercept, which makes sense: we should be hesitant to assign a large note-intercept value to a note whose ratings are also explained via a large note-content coefficient, since that suggests that much of the appeal of the note is due to partisanship rather than consensus. The name “diamond regularization” then suggests itself: we are penalizing notes that lie outside of the diamond shape on plots like the one above.

Rater helpfulness

Unsurprisingly, humans being humans, many users will give good prospective Community Notes bad ratings: for example, if the note is a consensus correction to a partisan tweet and the rater agrees with the perspective of the tweet. Because our threshold for unhelpfulness is so low, a few such early ratings can doom a good consensus-perspective note before it gets off the ground.

One way to combat this is to perform two rounds of our matrix-factorization algorithm. In the first round, the authors use all rating data to assign provisional ratings (using the same “helpful”/“needs more ratings”/“unhelpful” trichotomy as above) to all notes. Then they select for raters whose ratings generally agree with the provisional ratings, counting only ratings made before the provisional rating on a note became public. After a further filtering-out of raters who have authored low-quality Community Notes, all ratings by filtered-out raters are eliminated. In the paper’s example, roughly half of the raters and ratings remained after this filtering. Then a second round of matrix-factorization ratings are computed and used as the final ratings.