AI दृश्यता नमूना आकार: किसी संख्या को वास्तव में कितने दौड़ों की आवश्यकता है

TL;DR:

• एक ही AI उत्तर की एकल कैप्चर ने केवल 49.6% उद्धृत डोमेन को उजागर किया जो कि समान प्रॉम्प्ट की पांच कैप्चर ने उजागर किया, जिसे पांच उत्तर इंजनों, चार प्रॉम्प्टों और प्रत्येक इनपुट को स्थिर रखते हुए पांच पुनरावृत्तियों के 100-कैप्चर मैट्रिक्स के माध्यम से मापा गया।
• उद्धृत-डोमेन सेट्स पुनरावृत्तियों के बीच 0.384 की औसत जोड़ेवाले जैकार्ड के साथ ओवरलैप होते हैं, लेकिन व्यक्तिगत इंजन-और-प्रॉम्प्ट सेल 0.114 से 0.956 के बीच होते हैं — "AI दृश्यता" को कवर करने वाला कोई एकल स्थिरता आंकड़ा नहीं है।
• उत्तर पाठ के भीतर ब्रांड उल्लेख सबसे कम विश्वसनीय परत थे: 137 ब्रांड-बाय-सेल अवलोकनों में से, 44.5% सभी पांच पुनरावृत्तियों में दिखाई दिए और 24.8% बिल्कुल एक में दिखाई दिए।
• सेट-मेम्बरशिप प्रश्न जल्दी एकीकृत होते हैं — तीन पुनरावृत्तियों ने 83.1% उद्धृत डोमेन को पुनः प्राप्त किया जो पांच पुनरावृत्तियों ने पाया — इसलिए एक उद्धरण ऑडिट को कुछ रनों की आवश्यकता होती है, न कि दैनिक कैप्चर के एक चौथाई की।
• दर प्रश्न धीरे-धीरे एकीकृत होते हैं: एक देखी गई 40% उपस्थिति दर पर, पांच रनों से 95% अंतराल 65 अंक चौड़ा मिलता है, और ±10 अंक तक पहुंचने में लगभग 100 रनों की आवश्यकता होती है प्रति इंजन प्रति प्रॉम्प्ट।
• पूरा मैट्रिक्स 4 मिनट 9 सेकंड के भीतर चलाया गया, इसलिए ये आंकड़े मॉडल-स्तरीय अनिश्चितता को अकेले मापते हैं; एक प्रोग्राम को दिनों के बीच सैंपलिंग करते हुए कम से कम इस प्रकार की गति की अपेक्षा करनी चाहिए, कभी भी कम नहीं।
• अपने स्वयं के प्रॉम्प्ट सेट के खिलाफ समान मैट्रिक्स को Scrapeless मुफ्त योजना पर चलाएं और इस आंकड़े को उधार लेने के बजाय अपना स्वयं का नंबर प्राप्त करें।

हर AI-विज़िबिलिटी डैशबोर्ड एक संख्या को रिपोर्ट करता है। उद्धरण का हिस्सा, आवाज का हिस्सा, सिफारिश रैंक, भावना — प्रत्येक एक साफ आंकड़ा के रूप में एक प्रवृत्ति तीर के साथ आता है। इनमें से कोई भी एक त्रुटि बार के साथ नहीं आता।

यह चूक यहाँ क्लासिक खोज की तुलना में अधिक महत्वपूर्ण है, क्योंकि मापी जा रही सतह हर अनुरोध पर अपना उत्तर फिर से उत्पन्न करती है। शोधकर्ताओं ने आठ कार्यों के माध्यम से नाममात्र रूप से निर्धारक सेटिंग्स पर पांच मॉडलों को पिन किया और फिर भी रनों के बीच 15% तक की सटीकता में उतार-चढ़ाव दर्ज किया, जिसमें सबसे अच्छे और सबसे खराब संभावित रनों के बीच की खाई 70% तक पहुंच गई। एक मॉडल जो स्वयं को दोहराने के लिए कहा जाने पर नहीं दोहराता, वह एक कैप्चर से आपको कोई दोहराने योग्य दृश्यता संख्या नहीं देगा।

इस पोस्ट का बाकी हिस्सा समान प्रॉम्प्ट्स को समान इंजनों पर बार-बार चलाता है, प्रत्येक इनपुट को स्थिर रखता है, और मापता है कि उत्तर वास्तव में कितनी दूर बढ़ते हैं। उस मापी गई गति को तब एकमात्र आउटपुट में परिवर्तित किया जाता है जिस पर एक निगरानी कार्यक्रम कार्य कर सकता है — रनों की संख्या।

Pipeline at a Glance

पाइपलाइन के चार चरण होते हैं, और आखिरी चरण वह है जो प्रस्तुत किया जाता है:

दोहराने वाले मैट्रिक्स को कैप्चर करें → प्रत्येक उत्तर को तुलनीय परतों में घटाएँ → प्रति सेल स्थिरता को स्कोर करें → स्थिरता को आवश्यक नमूना आकार में परिवर्तित करें

चरण 1 कई बार प्रति इंजन एक समान अनुरोध डालता है और हर कच्चे उत्तर को संग्रहीत करता है। चरण 2 प्रत्येक उत्तर को तीन चीजों में कम कर देता है जो पुनरावृत्तियों के बीच की तुलना की जा सकती है: उद्धृत किए गए डोमेन का सेट, उत्तर का पाठ, और पाठ में किन निगरानी सूचियों के नामों का उल्लेख किया गया है और किस क्रम में। चरण 3 यह मापता है कि उन तीन परतों में से प्रत्येक पुनरावृत्तियों के बीच कितनी दूर बढ़ता है। चरण 4 मापी गई गति को लेता है और उस प्रश्न का उत्तर देता है जो एक रिपोर्टिंग टीम वास्तव में रखती है, जो है कि एक दावा के पीछे कितनी कैप्चर की आवश्यकता है।

यह उसके ऊपर एक परत पर बैठता है जिस पर यह निर्भर करता है। यदि आपने अभी तक कैप्चर साइड नहीं बनाई है, तो छह AI उत्तर इंजनों के बीच उद्धरण का हिस्सा पाइपलाइन आधारशिला है; यह पोस्ट मापता है कि क्या उस पाइपलाइन द्वारा उत्पन्न श्रृंखला आपके द्वारा चलाए जा रहे नमूना आकार पर पढ़ने योग्य है।

What This Measurement Answers

चार निर्णय उत्तर के आधार पर बदलते हैं, और सभी चार आज बिना उसके बनाए जा रहे हैं।

क्या साप्ताहिक परिवर्तन वास्तविक है। ऐसा उद्धरण का हिस्सा जो 40% से 25% तक गिरता है, वह एक पुनरागमन जैसा दिखता है। प्रति सेल पांच रनों पर, दोनों आंकड़े एक ही विश्वास अंतराल के भीतर होते हैं, इसलिए गिरावट इंजन के अपने उत्तर को फिर से उत्पन्न करने से अलग नहीं है।

एक कार्यक्रम को कितने कैप्चर बजट की आवश्यकता है। नमूना आकार सेट की लागत होती है। एक टीम जिसे दर अनुमान की आवश्यकता होती है और एक टीम जिसे उद्धरण सूची की आवश्यकता होती है, के पास आवश्यकताएँ होती हैं जो एक आदेश के मापदंड से अधिक भिन्न होती हैं, और दोनों के लिए बड़े वाले को खरीदना बजट का अधिकांश अनावश्यक रूप से बर्बाद करता है।

कौन सा मेट्रिक एक लक्ष्यों के चारों ओर बनाना है। AI उत्तर की कुछ परतें पर्याप्त स्थिर हैं कि उनके खिलाफ एक लक्ष्य स्थापित किया जा सके। अन्य नहीं हैं, और अस्थिर पर आधारित OKR बनाना एक चौथाई शोर का उत्पादन करता है जिसे प्रगति के रूप में व्याख्यायित किया जाता है।

कौन सा इंजन वजन देना है। इस मैट्रिक्स में प्रति-इंजन स्थिरता लगभग दो के कारक के अनुसार भिन्न होती है। एक इंजन जिसकी उद्धरण मुश्किल से हिलती है, आपको कुछ कैप्चर से एक उपयोगी पढ़ाई देता है; एक इंजन जिसे फिर से व्यवस्थित करना चाहिए, उसे समान विश्वास के लिए कई गुना अधिक नमूनाकरण की आवश्यकता होती है।

The Sample Design, Stated Up Front

मैट्रिक्स में पांच इंजन, चार प्रॉम्प्ट, पांच पुनरावृत्तियाँ: 100 कैप्चर, जिसमें 20 इंजन-और-प्रॉम्प्ट सेल पांच पुनरावृत्तियों को होल्ड करते हैं।

दो डिज़ाइन विकल्प परिणाम को प्रभावित करते हैं। पहला यह है कि हर इनपुट को पिन किया गया है: वही प्रॉम्प्ट स्ट्रिंग, वही देश, वही तर्किंग मोड, वही वेब-सर्च ध्वज। इनमें से किसी भी चीज़ में भिन्नता करने से इनपुट भिन्नताओं को विविधता में मिला दिया जाएगा और माप का कोई अर्थ नहीं रहेगा। स्टेज 1 में फ़िंगरप्रिंट की गणना यह साबित करने के लिए है कि पिनिंग बनी रही।

दूसरा संकुचित विंडो है। सभी 100 कैप्चर चार मिनट के भीतर हैं। यह जानबूझकर किया गया है, और यह पूरे अभ्यास की सबसे तेज़ सीमा भी है — यहाँ किसी भी आंकड़े को संदर्भित करने से पहले सीमा अनुभाग देखें।

पूर्व आवश्यकताएँ

• पायथन 3.10 या नया, केवल मानक पुस्तकालय।
• एक Scrapeless API कुंजी जो SCRAPELESS_API_KEY के रूप में निर्यात की गई हो। यूनिवर्सल स्क्रेपिंग एपीआई के तहत LLM चैट स्क्रेपर अभिनेता सभी पाँच इंजनों को एक एंडपॉइंट और एक प्रतिक्रिया लिफाफे के पीछे रखता है, जो क्रॉस-इंजन मैट्रिक्स को व्यावहारिक बनाता है।
• एक watchlist.txt फ़ाइल जिसमें प्रति रेखा एक ब्रांड नाम हो — आपका अपना ब्रांड और वे नाम जिनसे आप श्रेणी में प्रतिस्पर्धा करने की उम्मीद करते हैं। यदि सूची संवेदनशील है तो इसे संस्करण नियंत्रण से बाहर रखें।
• पहले पास के लिए बजट का लगभग 100 अभिनेता कॉल। उपयोग-आधारित मूल्य निर्धारण Scrapeless मूल्य निर्धारण पृष्ठ पर है।

export SCRAPELESS_API_KEY="your_scrapeless_api_key"
mkdir -p ai-visibility-variance && cd ai-visibility-variance
printf 'YourBrand\nRivalOne\nRivalTwo\n' > watchlist.txt

चरण 1 — दोहराव मैट्रिक्स को कैप्चर करें

चरण 1 हर सेल के पांच पुनरावृत्तियों को सक्रिय करता है और प्रत्येक कच्ची प्रतिक्रिया को बिना छुए डिस्क पर लिखता है। पूर्ण लिफाफे को संग्रहीत करना, parse की गई संक्षेपण की तुलना में, महत्वपूर्ण है, क्योंकि जिन स्तरों की आप तुलना करना चाहते हैं, वे स्पष्ट नहीं होते जब तक आप फैलाव को नहीं देखते।

प्रत्येक इंजन वही prompt और country लेता है; केवल अभिनेता-आवश्यक अतिरिक्त भिन्न होते हैं, और प्रत्येक अतिरिक्त को पिन किया गया है ताकि यह पुनरावृत्तियों के बीच नहीं बह सके। सेल समकालिक रूप से चलती हैं क्योंकि 100 कैप्चर पर एक शृंखलाबद्ध पास विंडो को खींच देगा और वास्तविक दुनिया की ड्रिफ्ट को एक माप में लीक करने देगा जो इसे छोड़ने के लिए होना चाहिए।

# capture.py — capture a fixed engine x prompt x repeat matrix
import hashlib
import json
import os
import time
import urllib.request
from concurrent.futures import ThreadPoolExecutor

API = "https://api.scrapeless.com/api/v2/scraper/execute"
KEY = os.environ["SCRAPELESS_API_KEY"]
OUT = "runs"
REPEATS = 5

PROMPTS = {
    "P1": "What are the best web scraping APIs for developers in 2026?",
    "P2": "Which services provide cloud browsers for automated data collection?",
    "P3": "What tools do developers use to collect Google search results programmatically?",
    "P4": "Recommend a proxy provider for large-scale public web data collection.",
}

# Same prompt and country everywhere. Only actor-required extras differ, and
# every one of them is pinned: an input that moves between repeats would be
# measured as engine variance.
ENGINES = {
    "perplexity": ("scraper.perplexity", {}),
    "grok":       ("scraper.grok",       {"mode": "MODEL_MODE_FAST"}),
    "gemini":     ("scraper.gemini",     {}),
    "aimode":     ("scraper.aimode",     {}),
    "chatgpt":    ("scraper.chatgpt",    {"web_search": True, "shopping": False}),
}


def execute(actor, payload, timeout=300):
    request = urllib.request.Request(
        API,
        data=json.dumps({"actor": actor, "input": payload}).encode(),
        headers={"Content-Type": "application/json", "x-api-token": KEY},
        method="POST",
    )
    started = time.time()
    with urllib.request.urlopen(request, timeout=timeout) as response:
        return json.loads(response.read().decode()), round(time.time() - started, 1)


def capture(job):
    engine, prompt_id, repeat = job
    actor, extra = ENGINES[engine]
    payload = {"prompt": PROMPTS[prompt_id], "country": "US", **extra}
    # Hash the actor with the payload. Three of these engines take an identical
    # payload, so a payload-only hash would collapse them into one fingerprint
    # and stop proving that each cell repeated the same request.
    fingerprint = hashlib.sha256(
        json.dumps({"actor": actor, **payload}, sort_keys=True).encode()).hexdigest()[:16]
    try:
        body, elapsed = execute(actor, payload)
    except Exception as exc:
        # A cell that returns nothing is logged as missing, never dropped.
        # A silent hole would bias every statistic computed downstream.
        return {"ok": False, "note": f"{engine} {prompt_id} r{repeat}: {type(exc).__name__}"}
    with open(f"{OUT}/{engine}__{prompt_id}__r{repeat}.json", "w") as handle:
        json.dump({
            "engine": engine, "prompt_id": prompt_id, "repeat": repeat,
            "elapsed_s": elapsed, "input_fingerprint": fingerprint,
            "captured_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
            "response": body,
        }, handle)
    return {"ok": True, "fingerprint": fingerprint}


os.makedirs(OUT, exist_ok=True)
jobs = [(e, p, r) for e in ENGINES for p in PROMPTS for r in range(1, REPEATS + 1)]
print(f"{len(jobs)} captures = {len(ENGINES)} engines"
      f" x {len(PROMPTS)} prompts x {REPEATS} repeats")

with ThreadPoolExecutor(max_workers=12) as pool:
    results = list(pool.map(capture, jobs))

stored = [r for r in results if r["ok"]]
print(f"stored {len(stored)} captures in {OUT}/")
print(f"missing cells: {[r['note'] for r in results if not r['ok']] or 'none'}")
print(f"{len({r['fingerprint'] for r in stored})} distinct input fingerprints "
      f"across {len(stored)} captures")

फ़िंगरप्रिंट रेखा ईमानदारी की जांच है। 100 कैप्चर में बीस अलग फ़िंगरप्रिंट का एक मतलब है कि प्रत्येक सेल के पांच पुनरावृत्तियाँ बाइट-एकसमान अनुरोध थीं, इसलिए जो कुछ भी प्रतिक्रियाओं में भिन्न है वह इंजन से आया।

चरण 2 — प्रत्येक कैप्चर को तीन तुलनीय स्तरों में कम करें

चरण 2 पांच विभिन्न प्रतिक्रिया लिफाफों को एक पंक्ति के आकार में समतल करता है जिसमें तीन माप स्तर होते हैं, क्योंकि "एआई दृश्यता" एक मात्रा नहीं है और इसे एक के रूप में मानना वह स्थान है जहाँ त्रुटि शुरू होती है।

तीन स्तर अलग-अलग प्रश्नों का उत्तर देते हैं और, जैसा कि परिणाम दिखाते हैं, उन्हें अलग-अलग नमूना आकार की आवश्यकता होती है:

प्रत्येक इंजन अपने स्वयं के कुंजी के तहत अपने स्रोतों की रिपोर्ट करता है — पेरप्लेक्सिटी web_results का उपयोग करता है, ग्रोक कुंजी footnotes को उद्धरण ID द्वारा, जेमिनी और एआई मोड दोनों citations का उपयोग करते हैं, और चैटजीपीटी की खोज पैनल search_result के रूप में आती है। पंजीकरण योग्य होस्ट पर सामान्यीकृत करना गहरे लेख URL और होमपेज लिंक के बीच का अंतर गिराता है, जो कि वास्तव में उद्धरण के हिस्से की मीट्रिक गिनती करता है।

# layers.py — reduce every capture to three comparable measurement layers
import json
import os
import re
from urllib.parse import urlparse

WATCHLIST = [line.strip() for line in open("watchlist.txt") if line.strip()]

CITATIONS = {
    "perplexity": lambda r: [c.get("url") for c in r.get("web_results") or []],
    "grok":       lambda r: [c.get("url") for c in (r.get("footnotes") or {}).values()],
    "gemini":     lambda r: [c.get("url") for c in r.get("citations") or []],
    "aimode":     lambda r: [c.get("url") for c in r.get("citations") or []],
    "chatgpt":    lambda r: [c.get("url") for c in r.get("search_result") or []],
}
ANSWER_KEY = {
    "perplexity": "result_text", "grok": "full_response", "gemini": "result_text",
    "aimode": "result_text", "chatgpt": "result_text",
}


def registrable(url):
    netloc = urlparse(url).netloc.lower()
    return netloc[4:] if netloc.startswith("www.") else netloc


def mentions(text):
    """Watchlist names present in the answer, keyed by first-mention offset."""
    lowered = text.lower()
    found = {}
    for name in WATCHLIST:
        hit = re.search(rf"(?<![a-z0-9]){re.escape(name.lower())}(?![a-z0-9])", lowered)
        if hit:
            found[name] = hit.start()
    return found


rows = []
for filename in sorted(os.listdir("runs")):
    record = json.load(open(f"runs/{filename}"))
    result = record["response"].get("task_result") or {}
    engine = record["engine"]
    answer = result.get(ANSWER_KEY[engine]) or ""
    found = mentions(answer)
    rows.append({
        "engine": engine,
        "prompt_id": record["prompt_id"],
        "repeat": record["repeat"],
        "cited_hosts": sorted({
            host for url in CITATIONS[engine](result)
            if url and (host := registrable(url))
        }),
        "answer_chars": len(answer),
        "answer_tokens": sorted(set(re.findall(r"[a-z0-9]+", answer.lower()))),
        # Ordered by first mention, so list position survives into stage 3.
        "brands_present": sorted(found, key=found.get),
    })

with open("layers.jsonl", "w") as handle:
    for row in rows:
        handle.write(json.dumps(row) + "\n")

cited = sum(len(r["cited_hosts"]) for r in rows)
print(f"reduced {len(rows)} captures -> layers.jsonl")
print(f"L1 citations: {cited} cited hosts, {cited / len(rows):.1f} per capture")
print(f"L2 prose:     {sum(r['answer_chars'] for r in rows) / len(rows):.0f} chars per answer")
print(f"L3 brands:    {sum(len(r['brands_present']) for r in rows)} watchlist hits total")

चरण 3 — प्रत्येक इंजन और प्रॉम्प्ट के लिए स्थिरता को स्कोर करें

चरण 3 प्रत्येक सेल के अंदर आंदोलन को मापता है, और यह पूलिंग के बजाय प्रति इंजन की रिपोर्ट करता है, क्योंकि पूल की गई संख्या उस चीज़ को छुपाती है जिसे आपको सबसे अधिक जानना आवश्यक है।

तीन आँकड़े काम करते हैं। उद्धरण और गद्य स्तरों के लिए, पांच पुनरावृत्तियों के बीच का औसत जोड़ीवार जैकार्ड इंडेक्स — इंटरसेक्शन का आकार यूनियन के आकार पर, एक सेल में सभी दस जोड़ों के औसत। उत्तर की लंबाई के लिए, परिवर्तन का गुणांक, जो मापी गई फैलाव का मानक विचलन को औसत के प्रतिशत के रूप में व्यक्त करता है ताकि विभिन्न लंबाई के उत्तर तुलनीय बने रहें। ब्रांडों के लिए, उन नामों का हिस्सा जो सभी पांच पुनरावृत्तियों में दिखाई दिए न कि उनमें से कुछ में।

# stability.py — how far each layer moves inside a cell
import json
import statistics as stats
from collections import defaultdict
from itertools import combinations

cells = defaultdict(dict)
for line in open("layers.jsonl"):
    row = json.loads(line)
    cells[(row["engine"], row["prompt_id"])][row["repeat"]] = row


def jaccard(left, right):
    union = left | right
    return len(left & right) / len(union) if union else None


def mean_pairwise(sets):
    scores = [j for a, b in combinations(sets, 2) if (j := jaccard(a, b)) is not None]
    return stats.mean(scores) if scores else None


per_engine = defaultdict(lambda: defaultdict(list))
brands = defaultdict(lambda: {"stable": 0, "flipping": 0})

for (engine, _prompt), reps in sorted(cells.items()):
    keys = sorted(reps)
    hosts = [set(reps[k]["cited_hosts"]) for k in keys]
    tokens = [set(reps[k]["answer_tokens"]) for k in keys]
    lengths = [reps[k]["answer_chars"] for k in keys]

    per_engine[engine]["cite"].append(mean_pairwise(hosts))
    per_engine[engine]["prose"].append(mean_pairwise(tokens))
    per_engine[engine]["cv"].append(stats.pstdev(lengths) / stats.mean(lengths) * 100)
    per_engine[engine]["union"].append(len(set().union(*hosts)))
    per_engine[engine]["core"].append(len(set.intersection(*hosts)))

    for brand in set().union(*[set(reps[k]["brands_present"]) for k in keys]):
        seen = sum(1 for k in keys if brand in reps[k]["brands_present"])
        brands[engine]["stable" if seen == len(keys) else "flipping"] += 1

header = f"{'engine':<12}{'citeJaccard':>12}{'proseJaccard':>13}{'lengthCV%':>11}"
print(header + f"{'hostsEveryRun':>15}{'brandsStable%':>15}")
for engine, series in per_engine.items():
    core, union = sum(series["core"]), sum(series["union"])
    counts = brands[engine]
    stable_pct = counts["stable"] / (counts["stable"] + counts["flipping"]) * 100
    print(f"{engine:<12}{stats.mean(series['cite']):>12.3f}"
          f"{stats.mean(series['prose']):>13.3f}{stats.mean(series['cv']):>11.1f}"
          f"{f'{core}/{union}':>15}{stable_pct:>14.1f}%")

चरण 4 — स्थिरता को नमूना आकार में परिवर्तित करें

चरण 4 प्रसार को रन गणना में बदल देता है, और यह दो बार ऐसा करता है क्योंकि दोनों प्रश्न प्रकार पूरी तरह से भिन्न व्यवहार करते हैं।

एक सेट-मेंबरशिप प्रश्न के लिए — यह इंजन मेरी श्रेणी के लिए कौन से डोमेन का हवाला देता है — उपयोगी आउटपुट एक कवरेज कर्व है: उन डोमेन का क्या भाग है जो पांच रन सतह करते हैं, एक रन, या दो, या तीन सतह करता है। यह प्रत्येक दोहराव के संयोजन के उपनिदान द्वारा सीधे कैप्चर से गणना की जाती है।

एक रेट प्रश्न के लिए — उत्तरों का क्या भाग मेरे ब्रांड का उल्लेख करता है — आउटपुट एक अनुपात पर आत्मविश्वास अंतराल है। विल्सन स्कोर अंतराल इस नमूना आकार पर सही उपकरण है: NIST का संदर्भ कार्यान्वयन इसे अनुपात आत्मविश्वास सीमाओं के लिए डिफ़ॉल्ट विधि बनाता है, और 1 से 1,000 तक के नमूना आकारों में प्रणालीगत तुलना ने पाया कि विल्सन अंतराल पाठ्यपुस्तक वाल्ड अंतराल से बेहतर है, विशेष रूप से छोटे n और 0 या 1 के करीब अनुपात पर। दोनों स्थितियाँ ब्रांड-उल्लेख डेटा का सटीक रूप से वर्णन करती हैं।

# samplesize.py — measured stability -> a required number of runs
import json
import math
import statistics as stats
from collections import Counter, defaultdict
from itertools import combinations

cells = defaultdict(dict)
for line in open("layers.jsonl"):
    row = json.loads(line)
    cells[(row["engine"], row["prompt_id"])][row["repeat"]] = row


def wilson(hits, runs, z=1.96):
    proportion = hits / runs
    denominator = 1 + z * z / runs
    centre = (proportion + z * z / (2 * runs)) / denominator
    half = z * math.sqrt(
        proportion * (1 - proportion) / runs + z * z / (4 * runs * runs)) / denominator
    return max(0.0, centre - half) * 100, min(1.0, centre + half) * 100


coverage = defaultdict(list)
for reps in cells.values():
    keys = sorted(reps)
    universe = set().union(*[set(reps[k]["cited_hosts"]) for k in keys])
    if not universe:
        continue
    for n in range(1, len(keys) + 1):
        coverage[n].append(stats.mean([
            len(set().union(*[set(reps[k]["cited_hosts"]) for k in combo])) / len(universe)
            for combo in combinations(keys, n)
        ]))

print("SET QUESTION — share of the 5-run cited-domain union that n runs surface")
for n in sorted(coverage):
    print(f"  n={n}: {stats.mean(coverage[n]) * 100:5.1f}%")

observed = Counter()
for reps in cells.values():
    keys = sorted(reps)
    for brand in set().union(*[set(reps[k]["brands_present"]) for k in keys]):
        observed[sum(1 for k in keys if brand in reps[k]["brands_present"])] += 1

total = sum(observed.values())
print(f"\nRATE QUESTION — {total} brand-by-cell observations at n=5")
for seen in sorted(observed):
    low, high = wilson(seen, 5)
    print(f"  seen {seen}/5 in {observed[seen]:>3} cases ({observed[seen] / total * 100:4.1f}%)"
          f"  95% interval {low:5.1f}%-{high:5.1f}%  width {high - low:4.1f}pt")

print("\nRATE QUESTION — interval width at a 40% appearance rate, by run count")
for n in (1, 5, 10, 20, 30, 50, 100, 200):
    low, high = wilson(round(0.4 * n), n)
    print(f"  n={n:<4} {low:5.1f}%-{high:5.1f}%  width {high - low:4.1f}pt")

मैट्रिक्स ने वास्तव में क्या दिखाया

सब कुछ चला गया, और इंजिनों ने समान मात्रा में गति नहीं की।

20 सेल्स में समेकित औसत जोड़ी जैकार्ड उल्लिखित डोमेनों पर 0.384 था। सेल-स्तरीय प्रसार अधिक उपयोगी आंकड़ा है: कम अंत पर 0.114 और उच्च अंत पर 0.956। एक इंजन पर एक संकेत से लिया गया स्थिरता का दावा उस रेंज में कहीं भी उतर सकता है, जो ठीक यही कारण है कि एक एकल इंजन पर तीन रन परीक्षण एक अग्रणी है और एक खोज नहीं।

कवरेज कर्व वह संख्या है जिसे लिखने के लिए सबसे अधिक महत्व है:

एक कैप्चर आपको लगभग आधा डोमेन दिखाता है जो पांच कैप्चर आपको दिखाते हैं। प्रति इंजन पर n=1 की रेंज पेरप्लेक्सिटी पर 73.6% से लेकर चैटजीपीटी पर 35.1% तक चलती है, इसलिए सबसे कम स्थिर इंजन पर एकल-कैप्चर उद्धरण ऑडिट लगभग दो तिहाई का अभाव है जो इसे सूचीबद्ध करना चाहिए। कर्व भी तेजी से समतल होती है: तीसरा रन 12.8 अंक जोड़ता है, चौथा 9.2 जोड़ता है। उद्धरण सूची के लिए, तीन से चार पुनरावृत्तियाँ उपलब्ध अधिकांश चीज़ों को खरीदती हैं।

गूगल एआई मोड ने चार संकेतों में 182 अलग-अलग मेज़बानों के साथ सबसे विस्तृत डोमेन संघ का उत्पादन किया, जिसमें से केवल 11 सभी पांच पुनरावृत्तियों में दिखाई दिए। गूगल की अपनी मार्गदर्शिका तंत्र को स्पष्ट करती है: एआई मोड और एआई ओवरव्यू एक क्वेरी फैन्स-आउट तकनीक का उपयोग कर सकते हैं जो उप-विषयों के बीच कई संबंधित खोजों को जारी करता है और इसलिए क्लासिक खोज की तुलना में अधिक विस्तृत और विविध लिंक सेट को सतह कर सकता है। जब एक इंजन अपने उद्धरणों को उप-विषयों के बीच फैलाने के लिए बनाया गया है, तो एक कैप्चर केवल उस प्रसार के एक भाग का नमूना लेता है।

रेट स्तर विपरीत कहानी बताता है। 137 ब्रांड-बाय-सेल अवलोकनों में, केवल 44.5% सभी पांच पुनरावृत्तियों में उपस्थित थे। 24.8% ठीक एक में दिखाई दिए — एक नाम जिसे एक अकेली कैप्चर या तो आत्मविश्वास के साथ उपस्थित या आत्मविश्वास के साथ अनुपस्थित रिपोर्ट करेगा, पूरी तरह से इस पर निर्भर करता है कि आपने कौन सी कैप्चर ली।

एक ब्रांड जिसे पांच रन में दो बार देखा गया है, उसकी सच्ची उपस्थिति दर कहीं 12% और 77% के बीच होती है, जो किसी भी कथन का समर्थन करने के लिए बहुत व्यापक है जिस पर एक हितधारक कार्य करेगा। नमूने को चौड़ा करने पर यह धीरे-धीरे संकीर्ण होता है:

दो छोटे परिणाम रिकॉर्ड करने के लायक हैं। रैंक ने उल्लेख की तुलना में कम बदलाव किया: नामों के बीच जो एक से अधिक दोहराव में मौजूद थे, पहले उल्लेख की स्थिति ChatGPT पर औसतन 0.89 स्थान और Grok पर 1.95 स्थान के द्वारा स्थानांतरित हुई, इसलिए एक रैंक-ट्रैकिंग मैट्रिक उल्लेख अस्थिरता को विरासत में लेती है लेकिन केवल थोड़ी सी अपनी जोड़ती है। और एक सेल — एक ही इंजन जो क्लाउड-ब्राउज़र प्रॉम्प्ट पर है — ने अपने पांच दोहराव में से किसी में भी कोई वॉचलिस्ट ब्रांड नहीं नामित किया, विक्रेताओं के बजाय क्षमता श्रेणियों में उत्तर दिया। एक निरंतर अनुपस्थिति भी एक स्थिर पढ़ाई है, और एक मॉनिटर जो एक खाली परिणाम को विफल कैप्चर के रूप में मानता है वह वास्तविक संकेत को फेंक देगा।

मापा गया फैलाव प्रकाशित शोध के साथ भी मेल खाता है, बल्कि इसके विपरीत नहीं। एक वैरिएंस-कंपोनेंट्स अध्ययन जिसने 20 ब्रांडों, 8 भाषाओं और 3 मॉडलों के बीच 12,933 LLM ब्रांड उत्तरों को डेकार्ड किया, रीसैंपलिंग अकेले कुल समानता के 34.8% के लिए जिम्मेदार था, एक एकल उत्तर की विश्वसनीयता लगभग 0.01 पर बैठी। उस अध्ययन ने एक अलग कॉर्पस और एक अलग सांख्यिकीय विधि का उपयोग किया और फिर भी उसी स्थान पर पहुंचा: एक उत्तर लगभग कोई भी ब्रांड-भेदक संकेत नहीं ले जाता।

यदि आप पहले से ही प्रति-इंजन ब्रांड भावना पाइपलाइन या एआई सिफारिश रैंक ट्रैकर चला रहे हैं, तो दोनों पाठ स्तर को पढ़ते हैं, और इसलिए दोनों धीरे-धीरे समकक्ष सैंपल आकार को विरासत में लेते हैं न कि तेज़ वाले को।

इस तालिका का अपना संस्करण प्राप्त करने में लगभग सौ कॉल लगते हैं। Scrapeless फ्री योजना पर शुरू करें और अपने लक्ष्यों पर किसी भी इन मैट्रिक्स से पहले अपनी प्रॉम्प्ट के खिलाफ मैट्रिक्स चलाएं।

यह मापन आपको क्या नहीं बता सकता

संकुचित कैप्चर विंडो वह सीमितता है जो ऊपर दिए गए हर आंकड़े को नियंत्रित करती है। सभी 100 कैप्चर्स एक ही दिन में 4 मिनट 9 सेकंड के भीतर आए। यह एक साफ़ तरीके से एक संचलन के स्रोत को अलग करता है — मॉडल अपने उत्तर को फिर से उत्पन्न कर रहा है — और यह पूरी तरह से कई अन्य स्रोतों को बाहर करता है: अनुक्रम अद्यतन, समाचार चक्र, सामग्री जो आप प्रकाशित करते हैं, मॉडल संस्करण परिवर्तन, और जो भी वास्तविक दिन-प्रतिदिन का प्रवास है जो इंजन को प्राप्त होता है।

परिणाम केवल एक दिशा में चलता है। ये संख्या एक मंजिल हैं, कुल भिन्नता का अनुमान नहीं। एक कार्यक्रम जो साप्ताहिक बारी-बारी से समान प्रॉम्प्ट का नमूना ले रहा है, उसे मॉडल-स्तर पर गैर-निश्चितता और चार-मिनट के विंडो में स्थिर रहने वाली हर चीज़ के लिए उजागर किया जा रहा है। इसलिए एक वास्तविक निगरानी कार्यक्रम के लिए आवश्यक नमूना आकार कम से कम इतना बड़ा होना चाहिए, और चार-मिनट के आंकड़े और चार-सप्ताह के आंकड़े के बीच का अंतर خود एक माप है जिसे यहाँ किसी ने नहीं बनाया है।

चार संकीर्ण सीमाएं लागू होती हैं:

• बीस कोशिकाएँ एक छोटा डिज़ाइन हैं। प्रति-इंजन आंकड़े चार प्रॉम्प्टों पर औसत हैं, इसलिए किसी इंजन की संख्या उस इंजन का सटीक अनुमान नहीं है। कोशिका-स्तर का रेंज 0.114 से 0.956 तक एक ईमानदार सारांश है कि एकल कोशिका कितना भिन्न हो सकती है।
• एक श्रेणी, एक भाषा, एक देश। सभी प्रॉम्प्ट एक उत्पाद श्रेणी में थे, अंग्रेजी में, US से चिपके हुए। ऊपर उद्धृत वैरिएंस-कंपोनेंट्स कार्य ने पाया कि क्वेरी भाषा ने कुल भिन्नता का 26.5% वहन किया, इसलिए एक अलग भाषा को ऐसा व्यवहार करने का अनुमान नहीं लगाया जाना चाहिए।
• विल्सन अंतराल स्वतंत्र खींचने का अनुमान लगाता है। एक सत्र में एक साथ पांच अनुरोध फायर करने से ऊपर की स्थिति साझा की जा सकती है, जिससे प्रभावी सैंपल आकार नामित एक से छोटा हो जाएगा और सही अंतराल व्यय टेबल में दिखाए गए से चौड़ा हो जाएगा।
• ब्रांड स्तर वॉचलिस्ट पर निर्भर करता है। केवल सूची पर नामित किए गए हैं, इसलिए एक प्रतियोगी जिसे आपने सूचीबद्ध नहीं किया है, वह L3 के लिए अदृश्य है जबकि अगर इंजन अपने डोमेन का उल्लेख करता है तो L1 के लिए पूरी तरह से दृश्य है।

इनमें से कोई भी शीर्षक परिणाम को तोड़ता नहीं है, जो कि समान स्थितियों के तहत मापे गए स्तरों के बीच एक तुलना है। वे इसका मतलब है कि विशिष्ट प्रतिशत इस मैट्रिक्स के अंतर्गत आते हैं, न कि सामान्य रूप से एआई उत्तरों के लिए।

संख्या को निगरानी कार्यक्रम में डालना

दो प्रश्न प्रकारों को अलग-अलग निर्धारित करें, क्योंकि दोनों के लिए एक तालमेल चलाना सेट प्रश्न के लिए अधिक भुगतान करता है और दर प्रश्न को कमज़ोर करता है।
उद्धरण सूची के लिए, प्रति इंजन प्रति प्रॉम्प्ट तीन से चार बार दोहराएँ, साप्ताहिक। यह प्रति कैप्चर राउंड उद्धृत-डोमेन ब्रह्मांड का 83% से 92% पुनर्प्राप्त करता है, और उस सेट पर साप्ताहिक अंतर पठनीय है। एक एकल रन की सूची के बजाय प्रति राउंड संघ को संग्रहीत करें; दो एकल रन की तुलना करने पर अक्सर पुनःसंप sampling से उत्पन्न होने वाले परिवर्तन उत्पन्न होते हैं।

मेट्रिक्स के लिए — उल्लेख शेयर, वॉयस शेयर, भावना शेयर, रैंक — एकत्र करें न कि स्नैपशॉट। प्रति सेल प्रति सप्ताह बीस कैप्चर साप्ताहिक आंकड़े पर लगभग ±20 अंकों के करीब एक अंतराल देता है और एक सामूहिक मासिक आंकड़ा लगभग ±10 के करीब होता है। हर बार संख्या के बगल में अंतराल रिपोर्ट करें। एक डैशबोर्ड जो 42% दिखाता है बिना 31%–50% दिखाए एक सटीकता का दावा कर रहा है जिसे कैप्चर डिजाइन समर्थन नहीं करता।

आप जो भी ताल चुनें, सब कुछ पिन करें। वही प्रॉम्प्ट स्ट्रिंग, वही देश, वही तर्क का तरीका। स्टेज 1 से इनपुट फ़िंगरप्रिंट आपके संग्रहीत पंक्तियों में होना चाहिए, ताकि भविष्य के विश्लेषक एक वास्तविक परिवर्तन को पहचान सकें जो किसी ने संपादित किया है।

जब इंजन में बदलाव होता है, फिर से मापें। स्थिरता वर्तमान मॉडल और पुनर्प्राप्ति स्टैक की एक विशेषता है, कोई स्थिरता नहीं। जब कोई इंजन एक दृश्यमान परिवर्तन भेजता है, तो रन गिनती जो पिछले तिमाही में पर्याप्त थी एक बार फिर एक परिकल्पना है। यहाँ वही अनुशासन लागू होता है जैसे किसी भी मॉडल मूल्यांकन में, जहाँ एक प्रतिनिधि डेटासेट की क्यूरेशन और एक अर्थपूर्ण कार्यप्रणाली का चयन मेट्रिक से पहले आता है, न कि उसके बाद।

निष्कर्ष: अंतराल की रिपोर्ट करें, बस संख्या नहीं

उपयोगी खोज यह नहीं है कि एआई उत्तर बदलते हैं। हर गाइड पहले ही यह कहता है। उपयोगी खोज यह है कि वे विभिन्न स्तरों पर विभिन्न मात्रा में चलते हैं, और आवश्यक नमूना आकार इसके अनुसार विभाजित होता है: उद्धरण सूची के लिए कुछ रन, एक रेट के लिए जिसे आप मीटिंग में बचाने की योजना बनाते हैं, लगभग सौ।

उस विभाजन के पीछे का डिज़ाइन चार फ़ाइलें और एक सौ कॉल हैं। इनपुट्स के साथ कैप्चर करें, तुलनीय स्तरों तक घटाएं, आंदोलन का स्कोर बनाएं, रन गिनती में परिवर्तित करें। इसे अपने प्रॉम्प्ट सेट के खिलाफ एक बार चलाएँ और आप एक ताल पर अनुमान लगाना बंद कर देंगे, क्योंकि आपके पास वह एक संख्या होगी जो हर एआई-दृश्यता डैशबोर्ड वर्तमान में गायब है — त्रुटि पट्टी।

अपनी एआई-दृश्यता भिन्नता मापने के लिए तैयार हैं?

पांच उत्तर इंजन एक एंडपॉइंट और एक प्रतिक्रिया लिफाफे के पीछे बैठते हैं Scrapeless Universal Scraping API, जो एक सौ कैप्चर मैट्रिक्स को एकल दोपहर बनाता है न कि पांच अलग-अलग एकीकरण। यहाँ इस्तेमाल किए गए हर अभिनेता के लिए पैरामीटर और प्रतिक्रिया आकार Scrapeless API दस्तावेज़ में हैं।

एक मुफ्त Scrapeless खाता बनाएं और अपनी दृश्यता संख्याओं पर एक त्रुटि पट्टी रखें।

अक्सर पूछे जाने वाले प्रश्न

प्रश्न: एक एआई-दृश्यता संख्या को वास्तव में कितने रन की आवश्यकता होती है?

यह स्तर पर निर्भर करता है, और दो उत्तर एक क्रमगणना के अधिक भिन्न होते हैं। इस मैट्रिक्स में, प्रति इंजन प्रति प्रॉम्प्ट तीन से चार बार दोहराने से उन्होंने 83% से 92% तक उद्धृत डोमेन पुनर्प्राप्त किया जो कि पांच बार दोहराने से प्रकट हुए, इसलिए उस नमूना आकार पर उद्धरण सूची पठनीय है। एक रेट मेट्रिक जैसे उल्लेख शेयर को लगभग 100 कैप्चर की आवश्यकता होती है प्रति इंजन प्रति प्रॉम्प्ट से पहले कि 95% अंतराल लगभग ±10 अंकों तक संकीर्ण हो, और पांच कैप्चर इसे लगभग 65 अंकों चौड़ा छोड़ते हैं।

प्रश्न: एक ही प्रॉम्प्ट और सेटिंग्स होने पर एआई के उत्तर क्यों बदलते हैं?

मोडल एक संभावना वितरण से नमूने लेते हैं और जो पुनर्प्राप्ति स्तर उन्हें फ़ीड करता है वह भी निश्चित नहीं है, इसलिए समान इनपुट समान आउटपुट की गारंटी नहीं देता। काम जिसने पांच मॉडलों को आठ कार्यों में नामांकित रूप से निश्चित सेटिंग्स पर पिन किया, फिर भी रन के बीच 15% तक की सटीकता में स्विंग रिकॉर्ड किया, और प्रभाव को इनफेरेंस बैच कैसे संसाधित किए जाते हैं के लिए जिम्मेदार ठहराया गया, न कि एक कॉन्फ़िगरेशन त्रुटि के लिए।

प्रश्न: क्या उद्धृत स्रोत उत्तर पाठ की तुलना में अधिक स्थिर होते हैं?

विश्वसनीयता से नहीं, और इतनी अधिक नहीं कि किसी भी स्तर पर पुनः नमूनाकरण को छोड़ दिया जाए। इस मैट्रिक्स में उद्धृत-डोमेन सेट का औसत जोड़ीदार जैकरड 0.384 पर ओवरलैप हुआ जबकि एकल कैप्चर ने केवल 49.6% उन डोमेन को प्रकट किया जो पांच कैप्चर ने प्रकट किए, इसलिए उद्धरण स्तर पर सापेक्षिक रूप से महत्वपूर्ण बदलती है। यह एक रेट मेट्रिक की तुलना में तेजी से समकक्ष होता है, जो स्थिर होने का एक अलग दावा है।

प्रश्न: क्या मैं जिस इंजन को ट्रैक करता हूँ वह यह बदलता है कि मुझे कितने रन की आवश्यकता है?
हाँ, उद्धरण स्तर पर लगभग दो गुना के कारक द्वारा। एकल कैप्चर ने इस मैट्रिक्स में सबसे स्थिर इंजन पर पांच-रन डोमेन संघ का 73.6% और सबसे अस्थिर पर 35.1% सतहरीकरण किया, इसलिए एक इंजन के लिए चुना गया रन काउंट दूसरे के लिए गलत होगा। प्रत्येक इंजन के लिए कवरेज कर्व की गणना करें बजाय इसके कि एक आंकड़ा पूरी जगह पर लागू किया जाए।

प्रश्न: क्या यह माप दिन-प्रतिदिन की बढ़ती कमी को भी मापता है?

नहीं। सभी 100 कैप्चर 4 मिनट 9 सेकंड के भीतर चले, जो मॉडल स्तर की गैर-निर्धारणता को अलग करता है और अनुक्रम अद्यतन, समाचार चक्र, सामग्री परिवर्तनों और मॉडल संस्करणों को बाहर करता है। यहाँ हर आंकड़े को एक फर्श के रूप में मानें: सप्ताहों के दौरान एक कार्यक्रम का सैंपलिंग इस भिन्नता को बनाए रखता है और वह सब कुछ जो संक्षिप्त खिड़की ने स्थिर रखा।

प्रश्न: क्या इस तरह से एआई उत्तरों को कैप्चर करना वैध है?

आपके द्वारा लिखी गई प्रॉम्प्ट्स के लिए सार्वजनिक रूप से उपलब्ध एआई उत्तरों को कैप्चर करना सामान्य सार्वजनिक-वेब डेटा संग्रह है, और यहाँ प्रॉम्प्ट्स और प्रतिक्रियाओं में कोई व्यक्तिगत डेटा शामिल नहीं है। मात्रा को सीमित और माप के अनुपात में रखें, केवल वही स्टोर करें जो विश्लेषण को चाहिए, और अपने क्षेत्राधिकार और उपयोग के मामले पर लागू होने वाले नियमों की जांच करें इससे पहले कि आप किसी कार्यक्रम को बड़े पैमाने पर चलाएँ।

प्रश्न: क्या मैं इसे बिना एआई एजेंट या एसडीके के चला सकता हूँ?

हाँ। यहाँ हर स्क्रिप्ट एक HTTPS एंडपॉइंट के खिलाफ पाइथन मानक पुस्तकालय है, इसलिए पूरा पाइपलाइन क्रॉन जॉब या सीआई कार्यक्रम के साथ चलता है बिना इसके कि पाइथन के अलावा कुछ और स्थापित किया गया हो। एकमात्र बाहरी निर्भरता एपीआई कुंजी है।