حالا یادگیری ماشین را می‌شناسید

یه چرخه

تبریک. ۹۳ تا درس، پونزده تا ایستگاه. اگه بخوایم همه‌ش رو توی یه تصویر بکشیم، می‌شه این:

داده میاد تو: مثال‌ها و جواب‌هاشون. مدل با عددهایی که الان داره یه حدس می‌زنه. فاصله‌ی حدس با جواب درست می‌شه خطا. شیب خطا می‌گه کدوم طرف بهتره، و مدل یه قدم کوچیک همون طرف می‌ره. بعد دوباره و دوباره، هزاران بار. آخرش هم روی داده‌ای که هیچ‌وقت ندیده سنجیده می‌شه، چون فقط همون نشون می‌ده واقعا یاد گرفته یا فقط حفظ کرده.

از رگرسیون خطی توی ایستگاه چهارم تا شبکه‌های عمیق، همه همین چرخه‌ان. فقط مدل بزرگ‌تر می‌شه و داده بیشتر. لازم نیست همه‌ی جزئیات یادتون باشه؛ مهم اینه که این چرخه رو بشناسید و بدونید هر چیزی توی کدوم ایستگاهه.

پونزده ایستگاه

1. شروع: یادگیری ماشین یعنی به جای نوشتن قانون، مثال بدیم تا ماشین خودش قانون رو پیدا کنه.
2. داده: هر ردیف یه مثاله، با ویژگی‌هایی که می‌دونیم و برچسبی که می‌خوایم حدس بزنیم؛ و باید تمیز بشه.
3. ریاضی: بردار و ماتریس برای نگه داشتن عددها، مشتق و گرادیان برای فهمیدن اینکه کدوم طرف بهتره.
4. اولین مدل: رگرسیون خطی: یه خط، یه تابع هزینه، و گرادیان کاهشی که قدم به قدم بهترش می‌کنه.
5. دسته‌بندی: به جای عدد، دسته؛ با احتمال و یه مرز تصمیم.
6. سنجش: دقت تنها گول می‌زنه؛ صحت، بازخوانی و خط پایه کمک می‌کنن.
7. تعمیم: خوب بودن روی داده‌ی ندیده مهمه؛ بیش‌برازش یعنی حفظ کردن به جای یاد گرفتن.
8. الگوریتم‌های کلاسیک: همسایه‌ها، درخت، جنگل، تقویت و ماشین بردار پشتیبان؛ هر کدوم برای یه جور داده.
9. بی‌نظارت: بی برچسب هم می‌شه یاد گرفت: گروه‌بندی، کم کردن ابعاد، پیدا کردن چیزهای عجیب.
10. شبکه‌ی عصبی: نورون‌های ساده، لایه به لایه؛ با پس‌انتشار یاد می‌گیرن.
11. آموزش شبکه‌ی عمیق: بهینه‌ساز، شروع درست وزن‌ها، دراپ‌اوت و توقف زودهنگام، تا شبکه‌ی عمیق هم یاد بگیره.
12. خانواده‌های شبکه: برای عکس، دنباله و ساختن داده، هر کدوم معماری خودش.
13. یادگیری تقویتی: یاد گرفتن از پاداش، با آزمون و خطا، بین کاوش و بهره‌برداری.
14. ابزار و کد: همین چند تیکه‌ی پایتون کافیه؛ و GPU برای ضرب‌های بزرگ.
15. دنیای واقعی: سوال و معیار، تحویل، پایش، رانش، انصاف و توضیح؛ مدل با تحویل تموم نمی‌شه.

یه پروژه از اول تا آخر

ببینید این ایستگاه‌ها توی یه پروژه‌ی واقعی، که این‌جا ساختگیه، چطور پشت سر هم به کار میان:

1. سوال. یه فروشگاه اینترنتی می‌خواد ایمیل‌های ناخواسته‌ی پشتیبانیش جدا بشن. سوال دقیق: «این ایمیل ناخواسته‌ست یا نه؟» و معیار: ایمیل درست، به اشتباه دور ریخته نشه. مراحل پروژه.
2. داده. ده هزار ایمیل قدیمی که یکی برچسب «ناخواسته» یا «سالم» روشون گذاشته. تکراری‌ها و خالی‌ها کنار می‌رن، متن به عدد تبدیل می‌شه. تبدیل به عدد.
3. دو دسته. یه بخش برای آموزش، یه بخش که مدل هیچ‌وقت نمی‌بینه، برای آزمون. آموزش و آزمون.
4. مدل ساده. اول یه خط پایه، بعد رگرسیون لجستیک، که با کراس‌انتروپی و گرادیان کاهشی آموزش می‌بینه. رگرسیون لجستیک.
5. سنجش. دقت ۹۵ درصده، ولی چون ایمیل‌های ناخواسته کم‌ان، این عدد گول می‌زنه. صحت رو بالا نگه می‌داریم، چون ایمیل سالم نباید دور ریخته بشه. صحت و بازخوانی.
6. بهتر. یه جنگل تصادفی امتحان می‌کنیم؛ روی آموزش عالیه، روی آزمون نه. بیش‌برازش؛ ساده‌ترش می‌کنیم. بیش‌برازش.
7. تحویل. مدل با یه اسم نسخه ذخیره می‌شه و هر ایمیل تازه رو، لحظه‌ای، جواب می‌ده. به کار گذاشتن.
8. شش ماه بعد. فرستنده‌های ناخواسته روششون رو عوض کردن و خطا بالا رفته. رانش؛ با داده‌ی تازه دوباره آموزش. رانش.
9. چرا. یه مشتری می‌پرسه چرا ایمیلش رفته توی ناخواسته‌ها. سهم هر ویژگی رو نگاه می‌کنیم: یه کلمه‌ی خاص بیش از اندازه وزن داشت. توضیح‌پذیری.

هیچ‌کدوم از این قدم‌ها جادو نبود. هر کدوم یه درس از همین مسیر بود؛ فقط پشت سر هم.

یه پروژه‌ی کامل، با کد

حالا همه‌ی مسیر رو یه بار دیگه، این بار با کد واقعی و عدد واقعی، کنار هم بذاریم. یه پروژه‌ی کوچیک ولی کامل: حدس قیمت آپارتمان. داده ساختگیه؛ خودمون ساختیمش تا بدونیم جواب درست چیه و ببینیم هر قدم چقدر بهمون نزدیک می‌شه. هر آپارتمان چهار تا ویژگی داره: متراژ، سن ساختمون، چند دقیقه پیاده تا مترو، و اینکه توی محله‌ی «الف»ه یا «ب». قیمتش هم از یه قانون مخفی ساخته شده، به‌علاوه‌ی یه کم شانس:

# 1. made-up flats: size (m2), age (years), minutes to the metro, area A or B -> price
random.seed(21)
def flat(boost=1.0):
    size, age, walk = random.uniform(40, 140), random.uniform(0, 40), random.uniform(2, 30)
    area_b = random.random() < 0.3
    price = (30 * size - 6 * age - 8 * walk + (200 if area_b else 0) + 800) * boost
    return [size, age, walk, area_b, price + random.gauss(0, 250)]
rows = [flat() for _ in range(400)]

# 2. two piles
random.shuffle(rows)
train, test = rows[:320], rows[320:]
mae = lambda guess, data: st.mean(abs(guess(r) - r[4]) for r in data)

قانون مخفی می‌گه هر متر ۳۰ میلیون، هر سال سن ۶ میلیون کمتر، هر دقیقه تا مترو ۸ میلیون کمتر، و محله‌ی «ب» ۲۰۰ میلیون بیشتر؛ به‌علاوه‌ی شانسی که به‌طور میانگین حدود ۲۰۰ میلیون بالا و پایین می‌ره. مدل این قانون رو نمی‌بینه؛ فقط ۴۰۰ تا آپارتمان و قیمتشون رو. بعد مثل درس آموزش و آزمون، ردیف‌ها رو به‌هم زدیم و ۳۲۰ تا رو برای آموزش و ۸۰ تا رو برای آزمون جدا کردیم. چون این داده زمانی نیست، به‌هم زدن شانسی این‌جا درسته.

خط پایه، مقیاس، و خط

قبل از هر مدلی، خط پایه:

# 3. a baseline
avg = st.mean(r[4] for r in train)
print("baseline:", round(mae(lambda r: avg, test)))

baseline: 679

اگه برای همه‌ی آپارتمان‌ها فقط میانگین قیمت‌های آموزش رو بگیم، به‌طور میانگین ۶۷۹ میلیون اشتباه می‌کنیم. این عددیه که هر مدلی باید ازش خیلی بهتر باشه. بعد ورودی‌ها رو هم‌اندازه می‌کنیم، با میانگین و پراکندگی که فقط از دسته‌ی آموزش گرفته شده؛ اگه از کل داده می‌گرفتیم، یه ذره از آزمون نشت می‌کرد. بعد یه خط، با همون گرادیان کاهشی که تویاز صفر، بی کتابخونه نوشتیم:

# 4. scale the inputs with the training pile only
cols = range(4)
mean = [st.mean(float(r[i]) for r in train) for i in cols]
sd = [st.pstdev(float(r[i]) for r in train) for i in cols]
scale = lambda r: [(float(r[i]) - mean[i]) / sd[i] for i in cols]

# 5. a straight line by gradient descent
w, b = [0.0] * 4, 0.0
for step in range(500):
    gw, gb = [0.0] * 4, 0.0
    for r in train:
        x = scale(r); err = sum(a * c for a, c in zip(w, x)) + b - r[4]
        gw = [g + 2 * err * c / len(train) for g, c in zip(gw, x)]; gb += 2 * err / len(train)
    w = [a - 0.1 * g for a, g in zip(w, gw)]; b -= 0.1 * gb
line = lambda r: sum(a * c for a, c in zip(w, scale(r))) + b
print("line:", round(mae(line, test)))

line: 204

اشتباه از ۶۷۹ رسید به ۲۰۴. یادتون باشه شانسی که توی داده گذاشتیم، خودش به‌طور میانگین حدود ۲۰۰ میلیون بود؛ یعنی خط تقریبا به بهترین جایی رسید که هر مدلی می‌تونست برسه. باقی‌مونده‌ی اشتباه، دیگه چیزی نیست که بشه یادش گرفت؛ شانس خالصه.

یه مدل دیگه، و یه سنجش مطمئن‌تر

حالا یه مدل کاملا متفاوت، نزدیک‌ترین همسایه‌ها: برای هر آپارتمان، ۵ تا آپارتمان آموزش که از همه بهش شبیه‌ترن رو پیدا کن و میانگین قیمتشون رو بگو:

# 6. nearest neighbours, for comparison
def knn(r, k=5):
    x = scale(r)
    near = sorted(train, key=lambda t: sum((p - q) ** 2 for p, q in zip(scale(t), x)))[:k]
    return st.mean(t[4] for t in near)
print("5 nearest:", round(mae(knn, test)))

5 nearest: 288

۲۸۸؛ از خط پایه خیلی بهتر، ولی از خط بدتر. چرا؟ چون قانون مخفی ما واقعا یه خطه، و مدلی که شکلش با شکل دنیا جوره، برنده می‌شه. اگه قانون پیچیده و پرپیچ‌وخم بود، شاید همسایه‌ها می‌بردن. این همون حرفیه که هیچ مدلی همه‌جا بهترین نیست، و باید امتحان کرد.

ولی ۲۰۴ فقط از یه بار تقسیم اومده. با اعتبارسنجی متقابل پنج‌تکه، داده رو پنج قسمت کردیم و هر بار یکی رو آزمون گذاشتیم:

five folds: [175, 168, 221, 211, 215]  average: 198

اشتباه بسته به اینکه کدوم آپارتمان‌ها توی آزمون افتادن، از ۱۶۸ تا ۲۲۱ بالا پایین رفت؛ میانگینش ۱۹۸. پس «حدود ۲۰۰، با چند ده تا بالا و پایین» جواب صادق‌تریه تا «دقیقا ۲۰۴».

یه پیچ، و دو تا دام

همون مدل همسایه‌ها یه پیچ داره: چند تا همسایه؟ چهار تا عدد امتحان کردیم و هر بار اشتباه رو هم روی خود آموزش و هم روی آزمون حساب کردیم:

k=1   train 0     test 341
k=5   train 204   test 288
k=20  train 267   test 240
k=80  train 399   test 345

با یه همسایه، اشتباه روی آموزش صفره؛ طبیعیه، چون نزدیک‌ترین همسایه‌ی هر آپارتمان آموزش، خودشه. ولی روی آزمون ۳۴۱؛ مدل فقط حفظ کرده. این همون بیش‌برازشه. با ۸۰ همسایه، اشتباه هم روی آموزش بالاست هم روی آزمون؛ مدل اون‌قدر میانگین گرفته که فرق آپارتمان‌ها رو نمی‌بینه، یعنی کم‌برازش. بهترین، این‌جا حدود ۲۰ همسایه بود، با ۲۴۰. این همون منحنی U شکل درس سوگیری و واریانسه، این بار با عدد خودمون. و یادتون باشه این پیچ رو باید با یه دسته‌ی جدا یا با اعتبارسنجی متقابل تنظیم کرد، نه با همون آزمون آخر؛ وگرنه آزمون دیگه آزمون نیست.

بعد از ساختن: گروه‌ها، ذخیره، و یه ماه بعد

سه کار آخر، از سه درس آخر مسیر:

# 7. each area on its own
for name, flag in (("area A", False), ("area B", True)):
    part = [r for r in test if r[3] == flag]
    print(name, len(part), "flats, line:", round(mae(line, part)))

# 8. keep the model
json.dump({"mean": mean, "sd": sd, "w": w, "b": b, "version": "2026-10-11"}, open("flat-model.json", "w"))

# 9. a month later, prices are 15 percent higher
later = [flat(1.15) for _ in range(80)]
print("a month later, line:", round(mae(line, later)))

area A 56 flats, line: 198
area B 24 flats, line: 219
a month later, line: 471

اول، سنجیدن جدا برای هر گروه، مثل درس سوگیری و انصاف: توی محله‌ی «الف» اشتباه ۱۹۸ و توی «ب» ۲۱۹. محله‌ی «ب» فقط ۲۴ تا آپارتمان توی آزمون داشت، پس عددش خودش شانسی‌تره؛ این‌جا فرق بزرگی نیست، ولی اگه بود، باید جدی گرفته می‌شد. دوم، ذخیره: میانگین‌ها، پراکندگی‌ها، وزن‌ها و نسخه توی یه فایل؛ یادتون باشه بدون میانگین و پراکندگی، وزن‌ها به درد نمی‌خورن، چون هر ورودی تازه باید دقیقا همون‌طور هم‌اندازه بشه. و سوم، یه ماه بعد: قیمت‌ها ۱۵ درصد بالا رفتن و اشتباه همون مدل از حدود ۲۰۰ پرید به ۴۷۱. این همون کهنه شدن مدله؛ وقت آموزش دوباره‌ست.

مدل چی یاد گرفت؟

همه‌ی عددهای پروژه کنار هم:

یه چیز قشنگ دیگه هم هست. چون مدلمون یه خطه، می‌شه وزن‌هاش رو به واحد خودشون برگردوند و خوند: هر متر ۲۹٫۹ میلیون، هر سال سن منفی ۶٫۴، هر دقیقه تا مترو منفی ۷٫۷، و محله‌ی «ب» ۲۴۳ میلیون بیشتر. قانون مخفی ما ۳۰، منفی ۶، منفی ۸ و ۲۰۰ بود. یعنی مدل، فقط از ۳۲۰ تا مثال، تقریبا همون قانون رو پیدا کرد؛ و محله که کمترین نمونه رو داشت، کمتر از همه دقیق دراومد. این همونجعبه‌ی سفیده: خود مدل توضیحشه.

کل این پروژه، از ساختن داده تا ذخیره‌ی مدل و سنجیدن یه ماه بعد، حدود ۵۵ خط پایتون خالیه، بی هیچ کتابخونه‌ی بیرونی، و روی یه لپ‌تاپ معمولی کمتر از یه ثانیه، ۰٫۲ ثانیه، طول کشید. هر تیکه‌ش رو توی یکی از درس‌های این مسیر دیده بودید؛ کار تازه‌ای نکردیم، فقط پشت سر هم گذاشتیمشون. پروژه‌های بزرگ هم همین اسکلت رو دارن؛ فقط داده بیشتره، مدل بزرگ‌تره، و هر قدم با دقت و ابزار بیشتری انجام می‌شه.

حالا از پس اینا برمیاید

وقتی کسی می‌گه «هوش مصنوعی یاد گرفته»، می‌دونید یعنی چی: یه چرخه‌ی حدس و خطا روی یه عالمه مثال. یه سوال رو طوری تعریف می‌کنید که بشه با داده جوابش داد، و یه معیار براش می‌ذارید. یه پروژه‌ی ساده رو با چند خط پایتون از فایل داده تا پیش‌بینی می‌برید؛ همون کاری که بالا با آپارتمان‌ها کردیم. وقتی یکی می‌گه «مدل ما ۹۹ درصد دقت داره»، می‌پرسید روی کدوم داده، خط پایه چنده، و برای هر گروه چقدر. و می‌دونید مدل کهنه می‌شه، ممکنه بی‌انصاف باشه، و باید بشه پرسید چرا.

زبان این رشته، توی چند پاراگراف

یه راه خوب برای اینکه ببینید چقدر یاد گرفتید، اینه که بتونید کل داستان رو با کلمه‌های خودش تعریف کنید. امتحانش کنیم. هر ردیف داده یه مثاله؛ ستون‌هایی که از قبل می‌دونیم ویژگی‌ان و ستونی که می‌خوایم حدسش بزنیم برچسبه. مدل یه تابعه که ویژگی‌ها رو می‌گیره و یه حدس پس می‌ده، و رفتارش رو چند تا عدد تعیین می‌کنه که بهشون پارامتر یا وزن می‌گیم. تابع ضرر می‌گه هر حدس چقدر بد بوده؛ برای عدد معمولا میانگین مربع خطا، برای دسته کراس‌انتروپی.

آموزش یعنی پیدا کردن وزن‌هایی که ضرر رو کم کنن. گرادیان کاهشی این کار رو قدم به قدم می‌کنه: مشتق ضرر نسبت به هر وزن می‌گه کدوم طرف بهتره، و نرخ یادگیری می‌گه چقدر بریم. توی شبکه‌ی عصبی، این مشتق‌ها رو پس‌انتشار، با قاعده‌ی زنجیره‌ای، از آخر به اول حساب می‌کنه. هر دور کامل روی داده یه دوره‌ست، و چون داده زیاده، معمولا با دسته‌های کوچیک جلو می‌ریم.

مدلی که آموزش رو حفظ کرده و روی داده‌ی تازه بده، بیش‌برازش داره؛ مدلی که حتی آموزش رو هم یاد نگرفته، کم‌برازش. برای همین داده رو به آموزش و آزمون تقسیم می‌کنیم، و پیچ‌هایی مثل تعداد همسایه یا عمق درخت رو، که بهشون ابرپارامتر می‌گیم، با یه دسته‌ی جدا یا با اعتبارسنجی متقابل تنظیم می‌کنیم. منظم‌سازی، رهاسازی و توقف زودهنگام راه‌هایی‌ان که جلوی حفظ کردن رو می‌گیرن.

سنجش هم کلمه‌های خودش رو داره. درستی سهم جواب‌های درسته؛ ماتریس درهم‌ریختگی می‌گه کجا اشتباه کردیم؛ صحت می‌گه از «آره»هامون چندتا درست بود و بازخوانی می‌گه از «آره»های واقعی چندتا رو پیدا کردیم. خط پایه ساده‌ترین حدسیه که هر مدلی باید ازش بهتر باشه. و بعد از تحویل، رانش یعنی دنیا عوض شده، انصاف یعنی برای همه‌ی گروه‌ها یه‌جور رفتار کنه، و توضیح‌پذیری یعنی بشه پرسید چرا. اگه این چهار پاراگراف براتون آشنا بود، یعنی این مسیر کارش رو کرده؛ اگه یه کلمه غریبه بود، درسش توی فهرست ایستگاه‌های بالا منتظرتونه.

از کجا شروع کنم؟

وقتی یه مسئله‌ی تازه جلوتونه، اول بپرسید جواب چه شکلیه. اگه یه عدده، مثل قیمت، رگرسیون؛ اگه یه دسته‌ست، مثل «ناخواسته یا سالم»، دسته‌بندی؛ اگه اصلا جوابی ندارید و فقط می‌خواید ببینید داده چه گروه‌هایی داره، خوشه‌بندی؛ و اگه یه عامل باید پشت سر هم تصمیم بگیره و پاداش بگیره، یادگیری تقویتی.

بعد بپرسید داده چه شکلیه. اگه یه جدوله با چند ده ستون، از یه خط یا یه درخت شروع کنید، و اگه کافی نبود، جنگل تصادفی یا تقویت گرادیانی؛ این‌ها روی جدول‌ها معمولا از شبکه‌های عصبی بهترن. اگه عکس، صدا یا متنه، شبکه‌ی عصبی، و خیلی وقت‌ها یه مدل آماده که فقط کمی تنظیمش می‌کنید. و همیشه، قبل از همه‌ی این‌ها، یه خط پایه. درس کدوم الگوریتم این نقشه رو مفصل‌تر کشیده.

دام‌هایی که توی کل مسیر دیدیم

اگه از کل این مسیر فقط یه چیز یادتون بمونه، این باشه: عدد خوب رو باور نکنید تا بپرسید از کجا اومده. توی همین مسیر، با عددهای واقعی، دیدیم که تقسیم شانسی داده‌ی زمانی، مدل نونوایی رو یک‌چهارم بهتر از واقعیت نشون داد؛ که مدل عکس‌ها روی آموزش ۹۵ درصد درست بود و روی عکس‌های تازه ۵۳ درصد، چون به یه علامت گوشه نگاه می‌کرد؛ که یه مدل وام برای یه گروه ۸۵ درصد و برای گروه دیگه ۷۲ درصد درست بود؛ که یه مدل نمره روی داده‌ی خودش ۰٫۷۳ اشتباه داشت و روی آزمون ۱٫۰۵؛ و همین بالا، که یه مدل خوب، یه ماه بعد، اشتباهش دو برابر شد.

هیچ‌کدوم از این‌ها خطای کد نبود؛ برنامه‌ها بی هیچ پیغام خطایی اجرا شدن. برای همین مهارت اصلی کسی که با یادگیری ماشین کار می‌کنه، نوشتن مدل نیست؛ پرسیدن سوال درست درباره‌ی عدده: روی کدوم داده؟ در برابر کدوم خط پایه؟ برای کدوم گروه؟ تا کی؟ و به چه دلیل؟

یه ادعای «۹۹ درصد»، با عدد

بیایید یه ادعای ساختگی رو با همین سوال‌ها بخونیم: «مدل ما یه بیماری رو با ۹۹ درصد دقت تشخیص می‌ده». فرض کنید از هر ۱۰۰۰ نفر، فقط ۱۰ نفر این بیماری رو دارن. اون‌وقت مدلی که به همه بگه «سالمی»، بی هیچ یادگیری‌ای، ۹۹۰ از ۱۰۰۰ بار درست می‌گه؛ یعنی ۹۹ درصد. پس عدد ۹۹ به‌تنهایی هیچی نمی‌گه؛ خط پایه‌ش هم ۹۹ بوده.

حالا یه مدل واقعی‌تر: از اون ۱۰ بیمار، ۸ تا رو پیدا می‌کنه، و ۵۰ نفر سالم رو هم به اشتباه بیمار می‌دونه. درستی کلیش ۹۴٫۸ درصده؛ کمتر از مدلی که هیچی یاد نگرفته! ولی ۸۰ درصد بیمارها رو پیدا کرده، که همون بازخوانیه. و از ۵۸ نفری که گفته بیمارن، فقط ۸ نفر واقعا بیمارن، یعنی صحتش حدود ۱۴ درصده. کدوم مدل بهتره؟ بستگی داره که از دست دادن یه بیمار چقدر بدتر از ترسوندن یه آدم سالمه؛ و این رو، مثل نونوایی، باید از کسی پرسید که با نتیجه زندگی می‌کنه، نه از عدد درستی.

کل راه، از کجا اومد

این مسیر روی دوش دویست سال کار آدم‌ها ساخته شده:

آدرین ماری لژاندر سال ۱۸۰۵ کمترین مربعات رو منتشر کرد، که هنوز پایه‌ی رگرسیون خطیه. وارن مک‌کالک و والتر پیتس سال ۱۹۴۳ اولین نورون ساختگی رو روی کاغذ کشیدن. فرانک روزنبلات سال ۱۹۵۸ پرسپترون رو ساخت، و آرتور ساموئل سال ۱۹۵۹، با برنامه‌ای که بازی چکرز رو یاد می‌گرفت، اسم «یادگیری ماشین» رو رایج کرد. روملهارت، هینتون و ویلیامز سال ۱۹۸۶ پس‌انتشار رو جا انداختن، و سال ۲۰۱۲ یه شبکه‌ی عمیق روی دو کارت گرافیک نشون داد این ایده‌ها با داده و حساب کافی چه کاری از دستشون برمیاد. بقیه‌ش، همون چیزیه که توی ۹۳ درس دیدید.

چیزهایی که این مسیر نگفت

این مسیر پایه رو کامل گفت، ولی یادگیری ماشین از این بزرگ‌تره و صادقانه‌ست که بدونید کجاها رو ندیدیم. پیش‌بینی سری‌های زمانی، مثل فروش هفته‌ی بعد، روش‌های مخصوص خودش رو داره که فصل و روند رو جدا می‌کنن؛ نونوایی فقط سرش رو نشون داد. سیستم‌های پیشنهاددهنده، که از روی انتخاب‌های میلیون‌ها نفر می‌گن شما چی دوست دارید، یه دنیای جدان. علت و معلول، یعنی اینکه «اگه این رو عوض کنم چی می‌شه»، با روش‌هایی جدا از پیش‌بینی معمولی سنجیده می‌شه؛ چند بار گفتیم مدل فقط «با هم اومدن» رو می‌بینه. و داده‌هایی که شکل شبکه دارن، مثل دوستی‌ها یا مولکول‌ها، مدل‌های مخصوص خودشون رو دارن.

بهترین راه ادامه، ساختن چیزیه. یه داده‌ی کوچیک از زندگی خودتون پیدا کنید، مثلا خرج‌های ماهانه یا ساعت خواب، یه سوال دقیق ازش بپرسید، و همین ۹ قدم پروژه‌ی آپارتمان‌ها رو روش برید. بعد عددهای همین درس‌ها رو با seed دیگه تکرار کنید و ببینید چقدر عوض می‌شن. و هر جا ادعای یه مدل رو دیدید، اون پنج تا سوال رو ازش بپرسید.

آزمون پایانی و راه بعد

آزمون پایانی مسیر از همه‌ی درس‌ها سوال داره: آزمون پایانی یادگیری ماشین. بعدش، سه تا راه جلوتونه که همه روی همین پایه ساخته شدن:

مدل زبانی: ماشینی که متن می‌نویسه، و چطور با همین چرخه، روی متن‌های خیلی زیاد، آموزش دیده. ترنسفورمر: معماری‌ای که پشت بیشتر مدل‌های امروزیه. بینایی ماشین: ماشینی که عکس رو می‌فهمه. هر کدوم رو خواستید شروع کنید؛ پایه‌ش رو دارید.