در این فصل چه یاد میگیری#
محیط را ثبت میکنیم، هر seed را میبندیم، و به چیزی میرسیم که میشود به آن تکیه کرد: دو اجرای پشتِ سرِ هم، اثرِ انگشتِ کاملاً یکسان — و آن اثرِ انگشت با عوض شدنِ seed تکان میخورد، پس بیخاصیت هم نیست.
بعد به دیوار میخوریم. شش فرآیندِ تازهٔ پایتون، شش ترتیبِ متفاوت از یک set میدهند، و هیچ خطی از کدِ داخلِ نوتبوک نمیتواند جلویش را بگیرد — چون تنها سوئیچی که خاموشش میکند باید قبل از روشن شدنِ مفسر تنظیم شده باشد. و همان اعداد با دو ترتیبِ متفاوت، دو جمعِ متفاوت میدهند.
این فصل هر دو را نشان میدهد: تا کجا قطعیت بهدست میآید، و از کجا به بعد فقط میشود صادق بود.

آخر این فصل میتوانی:
- محیط را طوری ثبت کنی که ماهها بعد بگوید دقیقاً چه چیزی عوض شده
- اثرِ انگشتِ اجرا بسازی و برابریِ دو اجرا را ثابت کنی، نه ادعا
- دو منبعِ ناقطعیتِ واقعی را با اندازهگیری نشان بدهی
- بگویی «بازتولیدپذیر است» یعنی دقیقاً چه ادعایی، و چه ادعایی نیست
قبل از شروع#
از فصلِ ۲: log_run، code_fp، data_fp. اینجا سومی را اضافه میکنیم: env_fp.
از سرنخ ترمِ ۵: seed و اینکه چرا نتیجه بدونش هر بار فرق میکند. این فصل همان درس است، ولی از سمتِ دیگرش: seed را بستیم؛ حالا چه چیزی هنوز تکان میخورد؟
📓 نوتبوک: نوتبوک این فصل را در Colab باز کن — همهٔ کدهای این فصل آماده و بهترتیب داخلش هست.
| اجرا | زمانِ تقریبی |
|---|---|
| کلِ نوتبوک روی CPU | کمتر از یک دقیقه |
| GPU | لازم نیست |
۱. محیط را ثبت کن#
import hashlib
import json
import platform
from importlib.metadata import version
PACKAGES = ["scikit-learn", "numpy", "scipy"]
def environment():
"""هر چیزی که بیرونِ کدِ توست و میتواند نتیجه را عوض کند."""
env = {"python": platform.python_version(),
"implementation": platform.python_implementation(),
"machine": platform.machine()}
for name in PACKAGES:
env[name] = version(name)
return env
def env_fp(env):
return hashlib.sha256(
json.dumps(env, sort_keys=True).encode("utf-8")).hexdigest()[:12]
ENV = environment()
for k, v in ENV.items():
print(f" {k:<16}{v}")
print("env_fp:", env_fp(ENV))
python 3.13.2
implementation CPython
machine AMD64
scikit-learn 1.7.2
numpy 2.4.6
scipy 1.17.1
env_fp: 07aa03401abd
عددهای بالا روی ماشینِ تو فرق دارند — و همین دلیلِ وجودِ این بخش است. نسخهٔ کتابخانهها یک متغیرِ پنهانِ آزمایشِ توست، و تنها راهِ دیده شدنش این است که ثبت شود. machine هم هست، چون معماریِ پردازنده میتواند ترتیبِ محاسبات را عوض کند (بخشِ ۵).
🔧 اگر کار نکرد:
PackageNotFoundError: No package metadata was found for sklearnیعنی نامِ بستهٔ نصبی را با نامِ ماژولِ ایمپورتی اشتباه گرفتهای.import sklearnدرست است، ولی بستهاشscikit-learnنام دارد. همین برایPIL(بستهاشPillow) وcv2(بستهاشopencv-python) هم صادق است. راهِ مطمئن: نامِ بسته را ازpip freezeبردار، نه از خطِimport.
۲. هر seed که از داخل بسته میشود#
import os
import random
import numpy as np
def set_all_seeds(seed):
"""هر منبعِ تصادفی که از داخلِ این فرآیند در دسترس است."""
os.environ["PYTHONHASHSEED"] = str(seed) # دیر است — بخشِ ۴ نشان میدهد چرا
random.seed(seed)
np.random.seed(seed)
set_all_seeds(0)
print("seedها بسته شدند")
seedها بسته شدند
۳. اثرِ انگشتِ اجرا#
متریک برای بازتولیدپذیری کافی نیست. دو مدلِ کاملاً متفاوت میتوانند F1 یکسان بدهند. چیزی که باید اثرِ انگشت بگیری، پیشبینیِ مدل برای تکتکِ ردیفهای آزمون است.
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.linear_model import LogisticRegression
def predictions(cfg):
cfg = DEFAULTS | cfg
texts = texts_for(cfg)
tr, te = random_split(len(Y), cfg["seed"])
if cfg["balance"] == "oversample":
tr = oversample(tr, cfg["seed"])
vec = CountVectorizer(min_df=cfg["min_df"], ngram_range=(1, cfg["ngram"]))
model = LogisticRegression(max_iter=2000, C=cfg["C"], random_state=cfg["seed"])
model.fit(vec.fit_transform([texts[i] for i in tr]), [Y[i] for i in tr])
return model.predict(vec.transform([texts[i] for i in te]))
def pred_fp(cfg):
"""اثرِ انگشتِ پیشبینیها — نه متریک، خودِ جوابِ مدل برای تکتکِ ردیفها."""
return hashlib.sha256(bytes(predictions(cfg).tolist())).hexdigest()[:16]
print("اثرِ انگشتِ اجرا:", pred_fp({"balance": "oversample"}))
اثرِ انگشتِ اجرا: bf4e08f40450ef6f
این عدد روی ماشینِ تو ممکن است فرق کند و آن هم اشکالی ندارد. چیزی که نباید فرق کند این است:
base = pred_fp({"balance": "oversample"})
print("دو اجرای پشتِ سرِ هم یکساناند؟", base == pred_fp({"balance": "oversample"}))
set_all_seeds(999)
print("بعد از set_all_seeds(999) هم؟ ", base == pred_fp({"balance": "oversample"}))
print("با seed دیگر یکسان است؟ ",
base == pred_fp({"balance": "oversample", "seed": 1}))
دو اجرای پشتِ سرِ هم یکساناند؟ True
بعد از set_all_seeds(999) هم؟ True
با seed دیگر یکسان است؟ False
سه خط، سه ادعای متفاوت. خطِ اول همان چیزی است که میخواستیم. خطِ دوم مهمتر است: seed سراسری را به ۹۹۹ عوض کردیم و هیچ اتفاقی نیفتاد — چون run هیچوقت به تصادفِ سراسری تکیه نمیکند و همهجا random.Random(seed) محلی میسازد. این طراحی است، نه شانس. و خطِ سوم میگوید اثرِ انگشت کور نیست: چیزی که باید عوضش کند، عوضش میکند.
✅ چک کن:
set_all_seedsرا کاملاً حذف کن و کلِ نوتبوک را دوباره اجرا کن. هر سه خط باید همان جواب را بدهند. اگر دادند، یعنی آزمایشت به تصادفِ سراسری وابسته نیست — که خودش یک آزمونِ سلامتِ ارزشمند است. اگر ندادند، جایی در کدتrandom.random()یاnp.random.rand()بیseedصدا زده میشود.
۴. جایی که قطعیت ممکن نیست — یک#
پایتون رشتهها را با یک عددِ تصادفیِ هر بار متفاوت hash میکند، پس ترتیبِ پیمایشِ یک set از رشتهها در هر اجرای تازهٔ مفسر فرق میکند. برای دیدنش، با subprocess شش مفسرِ تازه راه میاندازیم و خروجیشان را میشماریم — یک سلولِ نوتبوک همیشه در یک فرآیندِ واحد است و این تفاوت را نشان نمیدهد.
import subprocess
import sys
CHILD = (
"s = ['تشدید', 'پرداخت', 'ارسال', 'اپلیکیشن', 'حساب', 'متن',"
" 'مشتری', 'زمان', 'برچسب', 'مدل', 'آزمایش', 'نتیجه']\n"
"print('|'.join(set(s)))"
)
def child_orders(rounds, hash_seed):
env = dict(os.environ)
env["PYTHONIOENCODING"] = "utf-8"
if hash_seed is None:
env.pop("PYTHONHASHSEED", None)
else:
env["PYTHONHASHSEED"] = hash_seed
return [subprocess.run([sys.executable, "-c", CHILD], capture_output=True,
text=True, encoding="utf-8", env=env).stdout.strip()
for _ in range(rounds)]
free = child_orders(6, None)
fixed = child_orders(6, "0")
print("بدونِ PYTHONHASHSEED — هر ۶ اجرا یک ترتیب دادند؟", len(set(free)) == 1)
print("با PYTHONHASHSEED=0 — هر ۶ اجرا یک ترتیب دادند؟", len(set(fixed)) == 1)
بدونِ PYTHONHASHSEED — هر ۶ اجرا یک ترتیب دادند؟ False
با PYTHONHASHSEED=0 — هر ۶ اجرا یک ترتیب دادند؟ True
پس راهِ حلی هست. ولی حالا کاری را بکن که هر کسی اول از همه امتحان میکند — همان متغیرِ محیطی را از داخلِ نوتبوک تنظیم کن:
os.environ["PYTHONHASHSEED"] = "0"
child = subprocess.run([sys.executable, "-c", "print(hash('تشدید'))"],
capture_output=True, text=True, encoding="utf-8",
env=dict(os.environ, PYTHONIOENCODING="utf-8"))
print("این فرآیند با فرزندِ خودش همنظر شد؟",
hash("تشدید") == int(child.stdout.strip()))
این فرآیند با فرزندِ خودش همنظر شد؟ False
فرزند از متغیرِ محیطی پیروی میکند؛ خودِ این فرآیند نه. بذرِ hash در همان لحظهٔ روشن شدنِ مفسر خوانده میشود و بعدش قابلِ تغییر نیست. پس آن خطی که در set_all_seeds نوشتیم، برای فرآیندِ جاری هیچ کاری نمیکند — و عمداً همانجا گذاشتیمش تا اینجا رویش دست بگذاریم. راهِ درستش این است که مفسر را از بیرون با آن متغیر روشن کنی، و رابطِ Colab این را بهت نمیدهد.
چرا مهم است؟ چون هر جا کدی روی یک set از رشتهها حلقه بزند — یک واژگان، یک مجموعهٔ برچسب، یک فهرستِ ویژگی — ترتیبش در اجرای بعدی فرق میکند، و ترتیب (بخشِ بعد) بیاثر نیست. علاجِ عملی: هیچوقت روی set حلقه نزن؛ sorted(set(...)) بنویس.
۵. جایی که قطعیت ممکن نیست — دو#
rng = random.Random(0)
vals = [rng.uniform(-1, 1) for _ in range(20000)]
shuffled = vals[:]
random.Random(1).shuffle(shuffled)
print("جمعِ پایتون با جمعِ numpy برابر است؟ ",
sum(vals) == float(np.array(vals).sum()))
print("همان اعداد با دو ترتیب، در numpy برابرند؟",
float(np.array(vals).sum()) == float(np.array(shuffled).sum()))
جمعِ پایتون با جمعِ numpy برابر است؟ False
همان اعداد با دو ترتیب، در numpy برابرند؟ False
print("جمعِ پایتون :", repr(sum(vals)))
print("جمعِ numpy :", repr(float(np.array(vals).sum())))
print("numpy، ترتیبِ دوم:", repr(float(np.array(shuffled).sum())))
print("اختلافِ دو ترتیب :",
abs(float(np.array(vals).sum()) - float(np.array(shuffled).sum())))
جمعِ پایتون : 17.268048768837048
جمعِ numpy : 17.26804876883704
numpy، ترتیبِ دوم: 17.268048768837048
اختلافِ دو ترتیب : 7.105427357601002e-15
دقیقاً همان بیست هزار عدد، فقط با ترتیبِ متفاوت، دو جمعِ متفاوت. اختلاف در حدِ ۱۰ به توانِ منفیِ ۱۵ است و همین کوچکی گمراهکننده است: در یک محاسبهٔ زنجیرهای بزرگ میشود، و اگر جایی مقایسهٔ «بزرگتر از» انجام شود، یک بیتِ آخر میتواند یک تصمیم را برگرداند.
جمعِ اعشاری شرکتپذیر نیست، و کتابخانههای عددی برای سرعت جمع را تکهتکه و موازی انجام میدهند. تعدادِ تکهها به پردازنده، به تعدادِ نخها و به نسخهٔ کتابخانه بستگی دارد — هیچکدام از اینها زیرِ کنترلِ کدِ تو نیستند. روی GPU وضعیت بدتر است.
📏 اندازه بگیر: با چه چیزی مقایسه شد؟ یک محاسبه با خودش، فقط با ترتیبِ متفاوتِ همان اعداد. روی کدام داده؟ بیست هزار عددِ تصادفیِ
seedدار، پس خودِ داده کاملاً بازتولیدپذیر است — و همین است که ناقطعیتِ باقیمانده را به گردنِ محاسبه میاندازد، نه به گردنِ داده. با چندseed؟ یکی کافی است، چون ادعا «همیشه فرق میکند» نیست؛ ادعا این است که میتواند فرق کند و کردنش را دیدیم.
۶. پس «بازتولیدپذیر» یعنی چه#
RECORD = WORK / "run_record.json"
cfg = {"balance": "oversample", "seed": 0}
record = {"config": DEFAULTS | cfg, "env": ENV, "env_fp": env_fp(ENV),
"pred_fp": pred_fp(cfg), "metrics": run(cfg)}
RECORD.write_text(json.dumps(record, ensure_ascii=False, indent=1), encoding="utf-8")
print("ذخیره شد:", RECORD.name, "· کلیدها:", sorted(record))
def reproduce(path):
"""سه ماه بعد: همان پیکربندی را دوباره بزن و بگو دقیقاً چه چیزی فرق کرده."""
old = json.loads(path.read_text(encoding="utf-8"))
now = environment()
drift = [k for k in sorted(set(old["env"]) | set(now))
if old["env"].get(k) != now.get(k)]
return {"env_same": drift == [], "env_drift": drift,
"pred_same": pred_fp(old["config"]) == old["pred_fp"]}
print(reproduce(RECORD))
ذخیره شد: run_record.json · کلیدها: ['config', 'env', 'env_fp', 'metrics', 'pred_fp']
{'env_same': True, 'env_drift': [], 'pred_same': True}
حالا وانمود کنیم این رکورد مالِ سه ماه پیش است و از آن موقع همهچیز عوض شده:
faked = json.loads(RECORD.read_text(encoding="utf-8"))
faked["env"]["scikit-learn"] = "0.0.0"
faked["env"]["python"] = "3.0.0"
FAKED = WORK / "run_record_old.json"
FAKED.write_text(json.dumps(faked, ensure_ascii=False, indent=1), encoding="utf-8")
out = reproduce(FAKED)
print("محیط یکی است؟ ", out["env_same"])
print("چه چیزی فرق دارد؟ ", out["env_drift"])
print("پیشبینیها یکی است؟", out["pred_same"])
محیط یکی است؟ False
چه چیزی فرق دارد؟ ['python', 'scikit-learn']
پیشبینیها یکی است؟ True
رکورد دقیقاً نامِ دو چیزی را میدهد که عوض شدهاند. فرقِ این با «نتیجه بازتولید نشد» تمامِ ماجراست: اولی یک سرنخ است، دومی یک بنبست.
پس تعریفِ صادقانهای که از این فصل بیرون میآید:
- بازتولیدپذیریِ کامل — همان بیتها، همیشه، همهجا — تقریباً هیچوقت بهدست نمیآید و قول دادنش نادرست است.
- چیزی که بهدست میآید و کافی است: در همان محیط، همان پیکربندی همان اثرِ انگشت را میدهد؛ و اگر محیط عوض شده باشد، رکورد میگوید کدام قسمتش.
🤖 از دستیارت بپرس: «چرا
PYTHONHASHSEEDرا نمیشود بعد از شروعِ مفسر عوض کرد؟» بعد این را هم بپرس: «اگر کدم روی GPU اجرا شود، چه منابعِ ناقطعیتِ تازهای اضافه میشود و کدامشان را میشود خاموش کرد؟» — جوابِ دوم به دو گزینه میرسد که هر دو سرعت را کم میکنند، و همین معامله را باید آگاهانه انجام بدهی.
واژههای تازهٔ این فصل#
| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| reproducibility | ریپروداسیبیلیتی | رسیدن به همان نتیجه با همان ورودیها |
| environment capture | انوایرمنت کپچر | ثبتِ نسخهٔ پایتون و کتابخانهها و ماشین |
| hash randomization | هش رندومیزیشن | تصادفی بودنِ hash رشتهها در هر اجرای مفسر |
| non-determinism | نان-دترمینیسم | رفتاری که با ورودیِ یکسان همیشه یکسان نیست |
| floating-point associativity | فلوتینگ-پوینت اسوسیتیویتی | اینکه جمعِ اعشاری به ترتیب حساس است |
| prediction fingerprint | پردیکشن فینگرپرینت | اثرِ انگشتِ خروجیِ مدل روی کلِ دادهٔ آزمون |
تمرینها
اول خودت فکر کن یا امتحان کن — بعد اینجا را باز کن.
در فصل بعد#
حالا هر اجرا ثبت میشود و میدانیم تا کجا قابلِ بازتولید است. مسئلهٔ بعدی این است که اجراها مجانی نیستند. فضای پیکربندیِ ما همین الان هزاران حالت دارد و هر حالت وقت میبرد. فصلِ بعد بودجه را بهعنوان ورودیِ طراحی وارد میکند: با ۲۴ اجرا، جستوجوی شبکهای چه چیزی پیدا میکند و جستوجوی تصادفی چه چیزی — و کدامشان با همان بودجه به عددِ بهتری میرسد.
به آخر این فصل رسیدی!
اگر ساختی و جواب داد، این دکمه مال توست.