வெப்பநிலை 0 ஏன் தீர்மானிக்கப்படவில்லை?

செப்டம்பர் 2025 இல்திங்கிங் மெஷின்ஸ் ஆய்வகத்தில் ஹோரேஸ் அவரும் அவரது சகாக்களும் ஒரு எளிய பரிசோதனையை நடத்தினர். அவர்கள் “ரிச்சர்ட் ஃபெய்ன்மேன் பற்றி என்னிடம் சொல்லுங்கள்” என்ற கோரிக்கையை Qwen3-235B க்கு 0 வெப்பநிலையில் 1000 முறை அனுப்பி, ஒவ்வொரு முறையும் 1000 டோக்கன்களைக் கேட்டனர். 0 வெப்பநிலை என்றால், மாடல் எப்பொழுதும் அதன் மிகவும் சாத்தியமான அடையாளத்தைத் தேர்ந்தெடுக்கும், எனவே நீங்கள் 1000 ஒரே மாதிரியான பதில்களை எதிர்பார்க்கிறீர்கள். கிடைத்தது 80 தனித்துவமான முடிவுகள்.

என்ன கண்ணில் பட்டது எங்கே பதில்கள் பிரிக்கப்பட்டன. முதல் 102 எழுத்துகளுக்கு அனைத்து 1000 நிறைவுகளும் ஒரே மாதிரியாக இருந்தன. 103 மதிப்பெண்ணில், அவர்களில் 992 பேர் “குயின்ஸ், நியூயார்க்” மற்றும் 8 பேர் “நியூயார்க் சிட்டி” உடன் தொடர்ந்தனர். ஆயிரத்தில் எட்டு ரன்கள் ஒரே மார்க்காக மாறியது, 102 மதிப்பெண்களுக்குப் பிறகு, எதுவுமே செய்யவில்லை.

அவர்களின் செய்தி விளக்குகிறது ஏன் வெளியீடுகள் முற்றிலும் வேறுபட்டவை. இந்தக் கட்டுரை மற்றொரு கேள்வியைக் கேட்கிறது: டோக்கன் புரட்ட எவ்வளவு நேரம் ஆகும் மற்றும் ஆபத்து ஏன் அதிகமாக உள்ளது? நான் ஒரு வரி சூத்திரத்தைப் பெறுகிறேன், அதை உருவகப்படுத்துதல் மூலம் சரிபார்த்து, உண்மையான மாதிரியில் சோதனை செய்கிறேன். மடிக்கணினியில் எல்லாம் வேலை செய்கிறது மற்றும் குறியீடு கட்டுரையில் உள்ளது.

ஒலி எங்கிருந்து வருகிறது?

வெப்பநிலை 0 இல், மாடல் அதிக லாஜிட் (அதன் மூல மதிப்பெண்) கொண்ட டோக்கனைத் தேர்ந்தெடுக்கிறது. இது தீர்மானிக்கும் கணிதம், ஆனால் உங்கள் கணினியானது மிதக்கும் புள்ளியில் லாஜிட்களை கணக்கிடுகிறது, அங்கு கூட்டல் துணை இல்லை:

>>> 0.1 + 0.2 + 0.30.6000000000000001>>> 0.1 + (0.2 + 0.3)0.6

அளவில், அது மோசமாகிறது. நான் 100,000 random float32 எண்களை மூன்று வழிகளில் தொகுத்துள்ளேன். முன்னோக்கி வரிசை −90.82497 ஐக் கொடுத்தது, தலைகீழ் வரிசை −90.82674 ஐக் கொடுத்தது, மற்றும் NumPy சம தொகை −90.82513 ஐக் கொடுத்தது (float64 தரவு −90.82508) ஒரே எண்கள், மூன்று பதில்கள்.

ஒரு நரம்பியல் நெட்வொர்க் பில்லியன் டாலர்கள் செலவாகும், எனவே வன்பொருள் பயன்படுத்தப்படும் விதம் முக்கியமானது. சீரற்ற வரிசையில் முடிவடையும் GPU த்ரெட்களை ஒரு பொதுவான விளக்கம் குற்றம் சாட்டுகிறது. அவள் மற்றும் மற்றவர்கள். இது முக்கிய காரணம் அல்ல என்பதைக் காட்டுங்கள்: ஒரு பொதுவான LLM பாஸ் உண்மையில் அணு சேர்த்தல்களை உள்ளடக்காது, மேலும் அதே கர்னல் ஒவ்வொரு முறையும் ஒரே உள்ளீட்டில் அதே பிட்களை வழங்குகிறது. உண்மையான குற்றவாளி பல கோர்கள் அல்ல கட்சி-மாறாத. அவை குறைக்கப்படும் வரிசையானது தொகுதி அளவுடன் மாறுகிறது, மேலும் பகிரப்பட்ட சர்வரில் தொகுதி அளவு அந்த நேரத்தில் எத்தனை பேர் கோரிக்கைகளை அனுப்புகிறார்கள் என்பதைப் பொறுத்தது. உங்கள் பதில் அந்நியர்களைப் பொறுத்தது.

இது GPU களுக்குக் குறிப்பானது அல்ல என்று ஆசிரியர்கள் சுட்டிக் காட்டுகின்றனர், மேலும் தொகுதி மாறாத கர்னல்கள் அனைத்து 1000 Feynman நிறைவுகளும் ஒரே மாதிரியாக இருந்தன. பிழைத்திருத்தம் ஒரு விலையில் வருகிறது: அவர்களின் சேவை சோதனையில் (ஒற்றை GPU இல் Qwen-3-8B), இயல்புநிலை vLLM க்கு 26 வினாடிகள் மற்றும் ஃபோகஸ் கர்னல் மேம்படுத்தலுக்குப் பிறகு 42 வினாடிகளுடன் ஒப்பிடும்போது உகந்ததாக நிர்ணயிக்கப்பட்ட பதிப்பு 55 வினாடிகளைக் கொண்டிருந்தது.

நெருங்கிய தொடர்புகள் மட்டுமே முக்கியம்

இது ஒரு கணிதவியலாளனாக எனக்கு விருப்பமான பகுதி. z₁ மற்றும் z₂ இரண்டு பெரிய லாஜிட்களாக இருக்கட்டும் மற்றும் அவற்றின் வித்தியாசத்தை அழைக்கவும் விண்வெளி, $M = z₁ − z₂ ≥ 0$

8 லாஜிட் இடைவெளி கொண்ட டோக்கன் கர்னல் சத்தம் இருந்தாலும் சுழலவே முடியாது. நெருங்கிய இணைப்புகள் மட்டுமே ஆபத்தில் உள்ளன. எல்லா நிலைகளிலும் சராசரியாக, இடைவெளி அடர்த்தியுடன், சுழற்சி நிகழ்தகவு

p = ∫ P(Δ < −m) f(m) dm

சத்தம் சிறியதாக இருந்தால், f கிட்டத்தட்ட நிலையானது, f (0), குறுகிய வரம்பில் இருக்கும் $பி(Δ < -m)$

ப ≈ f(0) · E|Δ| / 2

ஒவ்வொரு அடையாளம் உருளும் நிகழ்தகவு, டை அக்கம் பக்கத்தில் எவ்வளவு நெரிசல் உள்ளது மற்றும் எவ்வளவு சத்தமாக உள்ளது என்பதைப் பொறுத்தது. முதல் காரணி மாதிரி மற்றும் உரையுடன் தொடர்புடையது. இரண்டாவது உங்கள் வன்பொருள், துல்லியம் மற்றும் கோர்களுடன் தொடர்புடையது. இது ஒரு எளிய சிறிய வம்பு வாதம், எனவே நான் புதுமையானதாகக் கூறவில்லை. தொடர்புடைய முறைப்படுத்தல், மெசினா மற்றும் ஸ்காட்டாவின் “பின்னணி வெப்பநிலை” (TMLR, 2026), இது போன்ற இடையூறுகளை பயனுள்ள வெப்பநிலையாகக் கருதுகிறது.

சூத்திரம் பின்பற்றப்படுகிறதா?

உண்மையான மாடலைத் தொடும் முன், தெரிந்த அடர்த்தி மற்றும் காஸியன் சத்தம் கொண்ட உருவகப்படுத்தப்பட்ட குழியில் சூத்திரத்தைச் சரிபார்த்தேன். $σ$. மையமானது ஒன்பது வரிகளைக் கொண்டுள்ளது:

def flip_rate(sampler, sigma, n, rng, chunk=5_000_000):    flips, done = 0, 0    while done < n:        m = min(chunk, n - done)        gap = sampler(rng, m)            # top-1 minus top-2 logit gap        err = rng.normal(0.0, sigma, m)  # numerical error on that gap        flips += np.count_nonzero(gap + err < 0)        done += m    return flips / n

அதிவேக மற்றும் அரை-வழக்கமான இடைவெளிக்கு, உருவகப்படுத்துதல் 4% க்குள் σ க்கு 0.03 வரை சூத்திரத்தைப் பொருத்துகிறது, மேலும் அரை-ஒழுங்குநிலை σ = 0.3 இல் கூட 2% க்குள் இருக்கும் (படம் 2). இரைச்சல் ஒரு பொதுவான இடைவெளியைப் போல பெரியதாக இருக்கும்போது, ​​​​அது உடைந்து விடும்: σ = 1 இல் அதிவேக கேஸ் எதிர்பார்க்கப்படும் 40% க்கு எதிராக 24% நேரத்தை வழங்குகிறது, ஏனெனில் அடர்த்தியானது முக்கியமான பகுதியில் தட்டையாக இருக்காது.

மூன்றாவது வழக்கு சூத்திரத்தின் அடிப்படை அனுமானத்தைக் காட்டுகிறது, $f(0) > 0$

உண்மையான மாதிரி

WikiText-2 இலிருந்து 128 டோக்கன்களின் 256 சாளரங்களில் GPT-2 ஐ இயக்கினேன். $bf16$ a உடன் முன்னோக்கி மாற்றம் $fp32$ ஒன்று இது உண்மையான சேவை இரைச்சலின் ஒரு அலகு: ஏற்றப்பட்ட GPU சேவையகத்தின் தொகுதி அளவு விளைவை எனது மடிக்கணினியால் மீண்டும் உருவாக்க முடியாது, ஆனால் இது குறைவான துல்லியமான கர்னல் உருவாக்கும் லாஜிட் பிழையை அளவிட முடியும். மின்மாற்றி பெட்டியை உள்ளே வைத்தேன் $bf16$மற்றும் வெளியீட்டுத் திட்டம் $fp32$எனவே, இறுதி பதிவுகள் வட்டமாக இல்லை $bf16$கரடுமுரடான கண்ணி.

import copy, numpy as np, torchfrom datasets import load_datasetfrom transformers import AutoModelForCausalLM, AutoTokenizerm32 = AutoModelForCausalLM.from_pretrained("gpt2").eval().float()m16 = copy.deepcopy(m32).to(torch.bfloat16)W = m32.get_output_embeddings().weight   # fp32 output matrix, both runstok = AutoTokenizer.from_pretrained("gpt2")data = load_dataset("wikitext", "wikitext-2-raw-v1", split="test")text = "\n\n".join(t for t in data["text"] if t.strip())ids = torch.tensor(tok(text)["input_ids"])n = len(ids) // 128ids = ids[: n * 128].reshape(n, 128)pick = torch.randperm(n, generator=torch.Generator().manual_seed(0))[:256]ids = ids[pick]

நான் வகிக்கும் ஒவ்வொரு பதவிக்கும் $fp32$ top-20 பதிவுகள், இடைவெளி, அந்த இடைவெளியில் பிழை $bf16$ ரன், மற்றும் argmax புரட்டப்பட்டதா. (வடிவமைப்பு குறியீடு அகற்றப்பட்டது.)

gaps, deltas, flips, top20 = [], [], [], []with torch.no_grad():    for x in ids.split(8):                 # x: [8, 128] token ids        h32 = m32.base_model(x).last_hidden_state[:, 4:]        h16 = m16.base_model(x).last_hidden_state[:, 4:].float()        ref = (h32 @ W.T).reshape(-1, W.shape[0])        alt = (h16 @ W.T).reshape(-1, W.shape[0])        v, i = ref.topk(20, dim=1)         # fp32 top-20 logits        a = alt.gather(1, i)               # same tokens, bf16 run        gap = v[:, 0] - v[:, 1]        gaps.append(gap.numpy())        deltas.append(((a[:, 0] - a[:, 1]) - gap).numpy())        flips.append((alt.argmax(1) != i[:, 0]).numpy())        top20.append(v.numpy())gap, delta, flip, top20 = map(np.concatenate,                              (gaps, deltas, flips, top20))

# density of the gap at 0 (per logit), and the error near tiesf0 = np.mean(gap < 0.25) / 0.25err = np.abs(delta[gap < 0.5]).mean()print(f"f(0) = {f0:.3f}, error near ties = {err:.4f}")print(f"flip rate: measured {flip.mean():.4f}, "      f"predicted {f0 * err / 2:.4f}")# inject noise of known size into the real logitsfor s in np.logspace(-3, 0.5, 8):    noise = np.random.randn(*top20.shape) * s    print(f"{s:.4f}", np.mean((top20 + noise).argmax(1) != 0))

குழியின் அடர்த்தி பூஜ்ஜியமாகும் $f(0) ≈ 0.83$

அறிகுறிகள் முதல் முனைகள் வரை

ஒரு முடிவுக்கு, உயிர்வாழ்வது என்பது ஒவ்வொரு கதாபாத்திரத்தின் உயிர்வாழும் நிகழ்தகவின் விளைபொருளாகும். $S$



Source link