خودرمزگذار (Autoencoder)

بازی سه کلمه

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

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

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

ساعت شنی

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

از سمت ورودی شروع کنیم. فرض کنید ورودی همین عکس خونه‌ست که ۳۶ تا خونه‌ی کوچیک یا همون پیکسل داره و هر پیکسل یه عدده؛ سیاه یعنی یک، سفید یعنی صفر. این ۳۶ تا عدد می‌رن توی لایه‌ی اول. هر لایه‌ی بعدی نورون‌های کمتری داره، پس داده مجبوره توی جای کوچیک‌تر و کوچیک‌تری جا بشه. به این نیمه که داده رو تنگ و تنگ‌تر می‌کنه می‌گن رمزگذار.

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

بعد نیمه‌ی دوم شروع می‌شه که دقیقا برعکس اولیه. از همون دو تا عدد شروع می‌کنه و لایه به لایه بزرگ‌تر می‌شه، تا آخرش دوباره ۳۶ تا عدد بده، یعنی یه عکس هم‌اندازه‌ی عکس اول. به این نیمه می‌گن رمزگشا. یه نکته‌ی مهم اینه که خروجی همیشه هم‌اندازه‌ی ورودیه، چون قراره همون رو دوباره بسازه. معمولا هر دو نیمه از لایه‌های تمام‌متصل ساخته می‌شن، همون شبکه‌ای که هر نورونش به همه‌ی نورون‌های لایه‌ی بعد وصله.

چطوری یاد می‌گیره

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

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

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

با پایتون

کوچیک‌ترین خودرمزگذار ممکن، با پایتون خالی: عکس‌های ۴ پیکسلی که در اصل فقط یه عدد پشتشونه، (t، ۲t، ۲t، t)، با یه کم نویز؛ یه رمزگذار که ۴ عدد رو به یه کد تبدیل می‌کنه و یه رمزگشا که از همون یه عدد، ۴ تا می‌سازه. خودمون اجراش کردیم:

import random
random.seed(1)

# made up: 4-pixel pictures that are really one number t: (t, 2t, 2t, t), plus a little noise
data = [[v + random.gauss(0, 0.05) for v in (t, 2 * t, 2 * t, t)]
        for t in (random.uniform(-1, 1) for _ in range(200))]

enc = [random.uniform(-0.5, 0.5) for _ in range(4)]   # 4 numbers -> 1 code
dec = [random.uniform(-0.5, 0.5) for _ in range(4)]   # 1 code -> 4 numbers
rate = 0.005

for epoch in range(1, 6):
    total = 0.0
    for x in data:
        code = sum(e * xi for e, xi in zip(enc, x))          # squeeze
        out = [d * code for d in dec]                         # rebuild
        err = [o - xi for o, xi in zip(out, x)]
        total += sum(e * e for e in err) / 4
        g_code = sum(e * d for e, d in zip(err, dec))         # how the code should move
        dec = [d - rate * e * code for d, e in zip(dec, err)]
        enc = [w - rate * g_code * xi for w, xi in zip(enc, x)]
    if True:
        print("round", epoch, "rebuild error", "%.6f" % (total / len(data)))

x = data[0]
code = sum(e * xi for e, xi in zip(enc, x))
print("picture", [round(v, 2) for v in x], "code", round(code, 2), "rebuilt", [round(d * code, 2) for d in dec])

round 1 rebuild error 0.835624
round 2 rebuild error 0.083071
round 3 rebuild error 0.002167
round 4 rebuild error 0.002126
round 5 rebuild error 0.002126
picture [-0.68, -1.53, -1.46, -0.67] code 2.32 rebuilt [-0.75, -1.48, -1.49, -0.75]

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

چرا وسطش تنگه

شاید بپرسید چرا وسط شبکه رو تنگ کنیم؟ خب اگه همه‌ی لایه‌ها هم‌اندازه‌ی ورودی باشن، ساختن دوباره خیلی راحت‌تر می‌شه. مشکل دقیقا همین راحتیه:

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

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

وقتی داده خمیده‌ست

گفتیم خودرمزگذار چندلایه می‌تونه الگوهای پیچیده‌تر از PCA بگیره. با عدد ببینیم. نقطه‌هایی روی یه دایره ساختیم و با یه ترکیب ثابت، توی ۱۰ ستون پخششون کردیم؛ یعنی هر نمونه ۱۰ تا عدد داره، ولی در اصل فقط یه چیز، جای روی دایره، پشتشه:

اگه فقط یه عدد اجازه داشته باشیم، PCA یه خط صاف رو برمی‌داره و هر نقطه رو روی اون خط می‌بره؛ ولی دو تا نقطه‌ی روبه‌روی هم روی دایره، روی خط به یه جا می‌افتن و از هم جدا نمی‌شن. خطای ساخت دوباره‌ی PCA با یه عدد ۰٫۱۶۳ شد. یه خودرمزگذار با لایه‌های غیرخطی، با همون یه عدد، خطای ۰٫۰۱۳ داشت؛ تقریبا سیزده برابر کمتر، چون کدش می‌تونه دور دایره «بپیچه».

با دو عدد، هر دو تقریبا بی‌خطا بودن، حدود ۰٫۰۰۰۳؛ چون یه دایره توی یه صفحه‌ی صاف کامل جا می‌شه. پس فرق اصلی وقتی پیدا می‌شه که بخوایم داده رو خیلی فشرده کنیم و داده روی یه شکل خمیده باشه؛ همون جایی که خط صاف کم میاره.

خلاصه و جستجو

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

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

یه کاربرد قشنگ دیگه، جستجوئه. فرض کنید یه عالمه سند یا عکس دارید و می‌خواید شبیه‌ترین‌ها رو به یه چیز پیدا کنید. اگه به جای مقایسه‌ی کل داده‌ها، هر کدوم رو به یه کد کوتاه از صفر و یک تبدیل کنید، می‌تونید چیزهایی که کد یکسان دارن رو یه‌جا نگه دارید و موقع جستجو، فقط برید سراغ همون دسته. اگه چیزهای کمی متفاوت‌تر هم خواستید، کافیه یکی دو تا از صفر و یک‌های کد رو عوض کنید و دسته‌ی کناری رو ببینید. این روش از سال ۲۰۰۷ برای جستجو معرفی شد و خیلی سریعه، چون مقایسه‌ی دو تا کد کوتاه خیلی ارزون‌تر از مقایسه‌ی دو تا سند بلنده.

پیدا کردن ناهنجاری

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

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

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

ناهنجاری، با عدد

همون خودرمزگذار دایره رو برای پیدا کردن ناهنجاری هم امتحان کردیم. نمونه‌های عجیب رو نقطه‌هایی گذاشتیم که روی یه دایره‌ی نصف‌اندازه بودن؛ چیزی که شبکه هیچ‌وقت ندیده بود:

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

نویزگیر

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

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

کار با عکس یکی از جاهاییه که خودرمزگذار خیلی به کار اومده. توی فشرده کردن عکس، یعنی کوچیک کردن حجمش با کمی از دست دادن جزئیات، خودرمزگذارها به جایی رسیدن که با یکی از روش‌های فشرده‌سازی استاندارد عکس به اسم JPEG 2000 رقابت کنن. توی عکس‌های پزشکی هم برای کم کردن نویز و بالا بردن وضوح عکس ازشون استفاده شده.

پراکنده و تغییراتی

از خودرمزگذار ساده، نسخه‌های دیگه‌ای هم ساختن که هر کدوم یه مشکل خاص رو حل می‌کنن. دو تا از معروف‌ترین‌هاشون این‌ها هستن:

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

دومی خودرمزگذار تغییراتی هست که اسم انگلیسیش Variational Autoencoder یا به اختصار VAE هست. توی خودرمزگذار معمولی، هر عکس دقیقا به یه نقطه توی فضای کد تبدیل می‌شه. توی نوع تغییراتی، هر عکس به یه ابر کوچیک تبدیل می‌شه، یعنی یه محدوده که کدش احتمالا اون اطرافه، و شبکه یاد می‌گیره این ابرها رو مرتب و کنار هم بچینه. فایده‌اش اینه که حالا می‌تونیم یه نقطه‌ی تازه از وسط این ابرها برداریم، که هیچ عکسی دقیقا روش نبوده، و بدیم به رمزگشا تا یه چیز تازه بسازه که شبیه داده‌های واقعیه. یعنی خودرمزگذار از خلاصه کردن به ساختن چیز تازه رسیده؛ مثلا سال ۲۰۱۹ مولکول‌هایی که با همین روش ساخته شده بودن، توی آزمایشگاه روی موش امتحان شدن. یه خانواده‌ی دیگه از شبکه‌ها هم برای ساختن چیز تازه هست به اسم شبکه‌ی مولد تخاصمی که با یه ایده‌ی کاملا متفاوت کار می‌کنه.

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

پوشوندن، به جای کوچیک کردن

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

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

اشتباه‌های رایج

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

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

اشتباه سوم توی پیدا کردن ناهنجاریه. اگه توی داده‌ی آموزش، نمونه‌های خراب هم زیاد قاطی باشن، شبکه ساختن اون‌ها رو هم یاد می‌گیره و دیگه خطاشون بالا نمی‌ره. پس یا داده‌ی آموزش رو فقط از نمونه‌های سالم بسازید، یا مطمئن بشید نمونه‌های خراب اون‌قدر کمن که روی یادگیری اثری نذارن.

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

از کجا اومد

خودرمزگذار از قدیمی‌ترین ایده‌های شبکه‌های عصبیه:

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

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