5D Library › Short-Video Completion Hazards, Recommender Exploration Loops and Automated Acquisition Funnels · 中文

Chapter 2. Tiered Traffic Pools and the First Gate

A stylised ladder of pools

Creators pass around a simplified picture of recommendation: each new video is shown to about 300 people; those near the top move on to a pool of 3,000, then 50,000, then 1,000,000. Real recommenders are far more complex, typically multi-stage neural networks that first retrieve candidates from a vast corpus and then rank them (Covington et al. 2016). This chapter claims to describe no platform; it asks one arithmetic question: if promotion depended on completion observed in a small sample, what would happen?

The program lets true completion rates follow a Beta distribution with mean 0.25, and lets each stage promote only the videos in the top 10% of observed completion; each stage’s audience also differs from the last by an “audience draw” with standard deviation ss on the logit scale.

Calculation

# Chapter 2. p03: How often does a good video die in the first pool?
# A stylised traffic-pool ladder: every new video is shown to 300
# viewers; the top 10 % by observed completion go on to 3,000, the top
# 10 % of those to 50,000, the top 10 % of those to 1,000,000. True
# completion rates p across videos follow Beta(5, 15) (mean 0.25).
# Each pool's audience also differs from the last: on the logit scale
# the rate a pool sees is shifted by N(0, s), the "audience draw".
# Observed rate = binomial(N, p') / N, normal approximation, clipped.
# "Good" means a true rate in the top 10 % of all videos; "best" means
# the top 0.1 %, as many videos as there are places in the last pool.
# 200,000 videos, fixed seed. False negative = a good video stopped.
import math
import random

STAGES = [300, 3000, 50000]

def logit(p):
    return math.log(p / (1 - p))

def expit(x):
    return 1 / (1 + math.exp(-x))

def run(s, n=200000, seed=8):
    rng = random.Random(seed)
    vids = [rng.betavariate(5, 15) for _ in range(n)]
    alive = list(range(n))
    reached = [alive]
    for N in STAGES:
        obs = []
        for i in alive:
            p = expit(logit(vids[i]) + rng.gauss(0, s)) if s else vids[i]
            x = p + rng.gauss(0, 1) * math.sqrt(p * (1 - p) / N)
            obs.append((x, i))
        obs.sort(reverse=True)
        alive = [i for _, i in obs[:len(obs) // 10]]
        reached.append(alive)
    srt = sorted(vids, reverse=True)
    t10, t1 = srt[n // 10], srt[n // 1000]
    good10 = [i for i in range(n) if vids[i] > t10]
    good1 = [i for i in range(n) if vids[i] > t1]
    s1 = set(reached[1])
    s3 = set(reached[3])
    fn1 = sum(1 for i in good10 if i not in s1) / len(good10)
    top1_to_end = sum(1 for i in good1 if i in s3) / len(good1)
    prec_end = sum(1 for i in s3 if vids[i] > t1) / len(s3)
    return t10, fn1, top1_to_end, prec_end, len(s3)

if __name__ == "__main__":
    print("   audience draw s   good videos stopped   best videos reaching")
    print("                     at 300                1,000,000")
    for s in (0.0, 0.2, 0.4):
        t10, fn1, reach, prec, m = run(s)
        print("   {:15.1f} {:21.3f} {:22.3f}".format(s, fn1, reach))
    print("   (top 10 % threshold on true completion {:.3f}; {} videos"
          .format(t10, m))
    print("   reach the last pool, so the share of best videos reaching")
    print("   it is also the share of the last pool that is best)")
    print("\nReading: with 300 viewers the observed rate has a standard")
    print("error of about 0.025, comparable to the gap between a good")
    print("and an average video, so 0.169 of good videos stop at the")
    print("first gate even when every audience is alike. Audience")
    print("variation between pools raises the loss to 0.308 or 0.478,")
    print("and then only about a half or a quarter of the best videos")
    print("reach the top pool.")
#    audience draw s   good videos stopped   best videos reaching
#                      at 300                1,000,000
#                0.0                 0.169                  0.970
#                0.2                 0.308                  0.525
#                0.4                 0.478                  0.245
#    (top 10 % threshold on true completion 0.378; 200 videos
#    reach the last pool, so the share of best videos reaching
#    it is also the share of the last pool that is best)
#
# Reading: with 300 viewers the observed rate has a standard
# error of about 0.025, comparable to the gap between a good
# and an average video, so 0.169 of good videos stop at the
# first gate even when every audience is alike. Audience
# variation between pools raises the loss to 0.308 or 0.478,
# and then only about a half or a quarter of the best videos
# reach the top pool.

With 300 viewers the observed completion rate has a standard error of about 0.025, comparable to the gap between a good and an average video. Even when every stage’s audience is alike, 0.169 of the true top 10% are stopped at the first gate; with an audience draw of 0.2 it is 0.308, with 0.4 it is 0.478. Only 200 videos reach the million pool; with identical audiences 0.970 of them are truly in the top 0.1%, with audience draws of 0.2 and 0.4 only 0.525 and 0.245. Most videos that reach the top are good, but most good videos never get there. The folklore of “thirty to forty percent killed at the first gate” matches this model for audience draws between 0.2 and 0.4.

Repost or re-edit: hedging the first gate

If the first gate is noisy, a creator will think of posting the same video again. If each attempt passes independently with chance qq, kk attempts pass at least once with 1−(1−q)k1-(1-q)^k; but each repost is recognised as duplicate content with chance dd, and a catch costs the account 1.5 times the value of a pass. A re-edit (a new opening, a new cover) counts as a new video and is never flagged, but costs 0.1 to make.

Calculation

# Chapter 2. p04: Reposting the same video: a hedging matrix.
# If one test pool is a noisy gate, a creator may post the same video
# again. Each attempt passes the first gate with chance q, independent
# of the others, so k attempts pass at least once with 1 - (1 - q)^k.
# A pass is worth V = 1. But each repost after the first is caught as
# a duplicate with chance d, and a catch costs the account P = 1.5
# (a traffic cut that lasts for weeks). Expected value of k attempts:
#     EV = 1 - (1 - q)^k - P * (1 - (1 - d)^(k - 1)).
# A re-edit (new opening, new cover) is treated as a fresh video: it
# is never flagged but costs E = 0.1 per attempt to make.
# q = 0.6 for a good video, 0.05 for an average one (illustrative).
P, E = 1.5, 0.1

def ev_repost(q, k, d):
    return 1 - (1 - q) ** k - P * (1 - (1 - d) ** (k - 1))

def ev_reedit(q, k):
    return 1 - (1 - q) ** k - E * (k - 1)

if __name__ == "__main__":
    for label, q in (("good video, q = 0.6", 0.6),
                     ("average video, q = 0.05", 0.05)):
        print("   " + label)
        print("   attempts k   d = 0    d = 0.2   d = 0.5   d = 0.8"
              "   re-edit")
        for k in (1, 2, 3, 4):
            row = [ev_repost(q, k, d) for d in (0.0, 0.2, 0.5, 0.8)]
            print("   {:10d}".format(k) + "".join(
                "{:9.3f} ".format(v) for v in row).rstrip() +
                "{:10.3f}".format(ev_reedit(q, k)))
        print()
    print("Reading: when duplicates are never caught, reposting a good")
    print("video is a cheap hedge against the noisy first gate. Once the")
    print("platform catches a fifth of reposts, a second post already")
    print("loses value, and one re-edit (0.740) is the better hedge.")
    print("For an average video re-edits never pay and reposts pay only")
    print("if nothing is ever caught. The fix is a better video.")
#    good video, q = 0.6
#    attempts k   d = 0    d = 0.2   d = 0.5   d = 0.8   re-edit
#             1    0.600     0.600     0.600     0.600     0.600
#             2    0.840     0.540     0.090    -0.360     0.740
#             3    0.936     0.396    -0.189    -0.504     0.736
#             4    0.974     0.242    -0.338    -0.514     0.674
#
#    average video, q = 0.05
#    attempts k   d = 0    d = 0.2   d = 0.5   d = 0.8   re-edit
#             1    0.050     0.050     0.050     0.050     0.050
#             2    0.098    -0.202    -0.652    -1.103    -0.002
#             3    0.143    -0.397    -0.982    -1.297    -0.057
#             4    0.185    -0.547    -1.127    -1.303    -0.115
#
# Reading: when duplicates are never caught, reposting a good
# video is a cheap hedge against the noisy first gate. Once the
# platform catches a fifth of reposts, a second post already
# loses value, and one re-edit (0.740) is the better hedge.
# For an average video re-edits never pay and reposts pay only
# if nothing is ever caught. The fix is a better video.

For a good video (q=0.6q = 0.6), reposting is a cheap hedge when duplicates are never caught: two attempts raise the expected value from 0.600 to 0.840. But once the platform catches a fifth of reposts, a second post already loses (0.540), and a single re-edit (0.740) is the better hedge. For an average video (q=0.05q = 0.05) re-editing never pays, and reposting pays only if nothing is ever caught. The real remedy is a better video.

Note

Practical consequence. When a video fails the first gate, check first whether its 3-second and 5-second retention are clearly below the account’s norm: if so, the problem is the opening, so re-edit the opening; if not, the video was probably stopped by noise and can be re-edited and tried once more. Do not repost it unchanged.

Summary

With a small-sample promotion gate, good videos being killed is the rule rather than the exception, and more so the more audiences differ. The right hedge against the noise is a re-edit, not a repost, and for an average video no hedge beats improving the content.

References

Covington, Paul, Jay Adams, and Emre Sargin. 2016. “Deep Neural Networks for YouTube Recommendations.” Proceedings of the 10th ACM Conference on Recommender Systems, 191–98.

Fan, Y. (2026). Short-Video Completion Hazards, Recommender Exploration Loops and Automated Acquisition Funnels: Weibull Swipe-Away Kinetics, Multi-Stage Pool Promotion Thresholds and Traffic-to-Cashflow Conversion Bounds [短视频完播率风险函数、推荐反馈环与自动化获客漏斗] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.24090213 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).