{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"

یک نقاش دیجیتال شو!

\n

به مانند مونه

\n

• GAN یا شبکه‌های متخاصم مولد

\n

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

\n

برای مشاهده اطلاعات بیشتر درباره این شبکه‌ها، به اینجا مراجعه کنید.

\n

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

\n

• آتوانکودرها

\n

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

\n

تصویر اولیه را عموما بردار نویز تصادفی هم می‌گویند. بردار نویز تصادفی را با Z عنوان می‌کنند، در یک فضای نهفته یا  latent space قرار دارد. فضای نهفته از فضای اصلی ما ابعاد کمتری دارد. به عنوان مثال فضای اصلی ما اگر تصاویر ما 28 در 28 پیکسل باشند، فضای نهفته ما می‌تواند 100 در یک می‌تواند باشد.

\n

\"\"

\n

Z یک برداری است که بازنمایی از داده را به صورت فشرده ارائه می‌کند. در خودکدگذارها به دنبال این هستیم که خروجی بسیار شبیه به ورودی ایجاد کنیم. یعنی تابع هزینه ما بر روی کاهش اختلاف ورودی و خروجی تمرکز دارد.

\n

در این شبکه‌ها نیاز به داده برچسب خورده نداریم، یعنی غیرنظارتی عمل می‌کنند. لازم نیست که توضیح داده شود تصویر ورودی چه چیزی است، ما به دنبال بازنمایی آن هستیم.

\n

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

\n

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

\n

نقص خودکدگذارها در تولید داده‌های شبیه به ورودی و واقعی نبودن تصاویر تولیدی است. به همین دلیل به دنبال راهکاری بوده‌ایم که این راهکار، همان گن‌ها می‌باشند.

\n

• تاریخچه گن‌ها\n

\n

شبکه‌های گن برای اولین بار بوسیله یان گودفلو در این مقاله در سال 2014 معرفی شدند. قابلیت اصلی این شبکه‌ها، مدل‌سازی داده می‌باشد. در این شبکه‌ها، دو قسمت تولیدکننده(generator) و تمایزدهنده(discriminator) وجود دارد.

\n

معماری این شبکه‌ها در شکل زیر آمده است:

\n

\"\"

\n

همانطور که می‌بینید یک بخش به نام تولیدکننده وجود دارد. ورودی این بخش یک بردار نویز تصادفی بر روی داده‌های فضای نهفته است. خروجی تولید کننده، یک داده‌ دروغین 'X است. در ادامه، این نمونه‌های تقلبی، همراه با یک سری داده واقعی X وارد یک تمایزدهنده می‌شوند. در تمایز دهنده، تلاش بر این است که بتوانیم داده‌های دروغی را تشخیص بدهیم، اما در نهایت به حالتی باید برسیم که تمایز دهنده، در تشخیص داده‌های واقعی و دروغی با مشکل مواجه شود.

\n

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

\n

تمایزدهنده دارای یک خطای دسته‌بندی (Classification loss) است که بر اساس آن خطا، دو مورد در شبکه کوک (tune) می‌شود:

\n

اول؛ تمایزدهنده تا بتواند بهتر تصایر را تشخیص دهد.

\n

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

\n

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

\n

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

\n

• توابع هزینه در شبکه‌های گن

\n

در این معماری، دو تابع هزینه داریم: تابع هزینه شبکه تولیدکننده و تابع هزینه شبکه تمایزدهنده. برای مطالعه بیشتر توابع هزینه‌ها اینجا را ببینید.

\n

J(G) , θ(G)

\n

J(D) , θ(D)

\n

J(G)             (θ(G), θ(D))

\n

J(D)             (θ(D), θ(G))

\n

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

\n

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

\n

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

\n

• تعادل نش

\n

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

\n

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

\n

• آموزش در گن

\n

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

\n

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

\n

• نکات آموزش

\n

نرمال‌سازی: تصاویر ورودی عموما بین 1 و 1- قرار می‌گیرند.

\n

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

\n

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

\n

تابع‌فعال‌ساز: در این شبکه‌ها به جای استفاده از رلو و مکس‌پولینگ، از لیکی‌رلو (LeakyRelu) استفاده می‌کنیم. یکی از مشکلات تابع رلو، مرگ‌رلو است که برخی از نورون‌ها می‌میرند و غیرفعال می‌شوند و برای تمامی ورودی‌ها،  صفر را در خروجی می‌دهند. در این حالت، هیچ گرادیانی جریان نمی‌یابد و در صورتی‌که تعداد نورون‌های غیرفعال در شبکه عصبی زیاد باشد، عملکرد مدل تحت تأثیر قرار می‌گیرد. برای حل این مشکل می‌توانیم از تابع لیکی‌رلو استفاده می‌کنیم.

\n

\"\"

\n

• انواع گن

\n

• ساده

\n

در آن‌ها تولیدکننده و تمایزدهنده از شبکه‌های ساده عصبی استفاده می‌کنند.

\n

• گن‌های پیچشی

\n

در این مدل از گن‌ها، در بخش تولیدکننده و تمایزدهنده از شبکه‌های عصبی کانولوشن استفاده می‌شود. در تولیدکننده، از عمل کانولوشن معکوس استفاده می‌شود. کانولوشن معکوس، در هر لایه، عملی عکس کانولوشن معمولی انجام می‌دهد. در لایه کانولوشن معمولی، یک ورودی را با Downsample کردن کوچک می‌کنیم، به این معنا که یک بازنمایی از کل ویژگی‌های درون ورودی به صورت خلاصه‌تر ایجاد کرده‌ایم. اما در کانولوشن معکوس، عملی خلاف روش بالا انجام می‌شود، یعنی Upsample می‌کنیم. در این حالت، خروجی از ورودی بزرگتر است و می‌توان گفت که از روی خصیصه‌ها، ما داده‌ای را تولید می‌کنیم.

\n

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

\n

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

\n

پس در حالت کلی تولیدکننده با استفاده از upsample کردن، یک تصویر ایجاد می‌کند و تمایزدهنده با downsample کردن تصویر در پی تفکیک داده‌های دروغی از واقعی است.

\n

• گن‌های شرطی

\n

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

\n

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

\n

• گن‌های چرخشی

\n

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

\n

• گن‌های چرخشی

\n

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

\n

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

\n

ثبات خطا؛ گن‌های چرخشی از خطای ثبات چرخش (Cycle Lost Consistency) استفاده می‌کند تا بدون نیاز به داده‌های جفتی، بتوانیم مدل را آموزش دهیم. در مجموعه داده‌های جفت نشده، هیچ تبدیل معناداری از پیش تعریف شده ای وجود ندارد که تولیدکننده بتواند آن را بیاموزد، بنابراین آن را ایجاد خواهد کرد.

\n

در این رقابت، یک تصویر واقعی به تولید کننده نقاشی مونه داده می‌شود و این تولیدکننده آن را به نقاشی مونه تقلبی تبدیل می‌کند و خروجی شبکه در این مرحله به یک تولیدکننده تصویر داده می‌شود و این تولید کننده باید آن را تبدیل به یک تصویر کند، این تصویر را تصویر دوار می‌گوییم.

\n

بنابراین هدف یادگیری عبارت است از:

\n

نگاشت G:X→Y به گونه ای که تصویر G(X) از تصاویر Y قابل تشخیص نباشند.

\n

نگاشت F:Y→X به گونه ای که تصویر F(Y) از تصاویر X قابل تشخیص نباشد.

\n

برای محاسبه خطای کل تولید‌کننده‌ها از موارد زیر استفاده می شود:

\n

خطای تولید کننده، خطای تولید تصویر دوار، خطای هویت

\n

دو تولیدکننده داریم، یک تولید کننده تصویر و یک تولید کننده نقاشی مونه که در معماری U-Net کار را انجام می‌دهند.

\n

تولیدکننده مونه یاد می گیرد که چگونه یک عکس را به نقاشی مونه تبدیل کند

\n

تولیدکننده تصویر یاد می گیرد که چگونه نقاشی مونه را به تصویر تبدیل کند

\n

از آنجایی که تصاویر جفت نیستند، استفاده از دو چرخه ضروری است

\n

عکس ورودی -> تولیدکننده مونه -> نقاشی جعلی -> تولیدکننده تصویر-> تصویر دوار

\n

نقاشی ورودی -> تولیدکننده تصویر-> عکس جعلی -> تولیدکننده مونه -> مونه دوار

\n

دو تمایزدهنده هم داریم، یک تمایزدهنده مونه و یک تمایز دهنده تصویر که در معماری PatchGAN کار را انجام می‌دهند و سعی می کنند طبقه بندی کند که آیا هر تیکه در یک تصویر واقعی است یا جعلی.

\n

تمایزدهنده نقاشی مونه یاد می‌گیرد که واقعی یا تقلبی بودن یک نقاشی مونه را از هم تفکیک کند، و برای بهبود تولیدکننده مونه کار می‌کند.

\n

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

\n

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

\n

• معماری گن‌های چرخشی

\n

معماری این شبکه‌ها به شکل زیر است:

\n

\n

منبع: مقاله معرفی گن‌های چرخشی

\n

به صورت خلاصه و به عنوان یک طرح کلی، مراحل زیر در هر مرحله از آموزش انجام خواهد شد:

\n

با دو ورودی شروع می‌کنیم:

\n

یک عکس (عکس ورودی)

\n

یک نقاشی مونه (مونه ورودی)

\n

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

\n

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

\n

\"\"

\n

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

","metadata":{}},{"cell_type":"markdown","source":"

• نیازمندی‌ها

\n

ابتدا نیازمندی‌های کار را وارد می‌کنیم و بعد استفاده از TPU را تنظیم می‌کنیم.

","metadata":{}},{"cell_type":"code","source":"import tensorflow as tf\nfrom tensorflow import keras\nfrom tensorflow.keras import layers\nimport tensorflow_addons as tfa\n\nfrom kaggle_datasets import KaggleDatasets\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ntry:\n tpu = tf.distribute.cluster_resolver.TPUClusterResolver()\n print('Device:', tpu.master())\n tf.config.experimental_connect_to_cluster(tpu)\n tf.tpu.experimental.initialize_tpu_system(tpu)\n strategy = tf.distribute.experimental.TPUStrategy(tpu)\nexcept:\n strategy = tf.distribute.get_strategy()\nprint('Number of replicas:', strategy.num_replicas_in_sync)\n\nAUTOTUNE = tf.data.experimental.AUTOTUNE\n \nprint(tf.__version__)","metadata":{"_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","execution":{"iopub.status.busy":"2022-02-17T07:13:55.969199Z","iopub.execute_input":"2022-02-17T07:13:55.969571Z","iopub.status.idle":"2022-02-17T07:14:04.489086Z","shell.execute_reply.started":"2022-02-17T07:13:55.969538Z","shell.execute_reply":"2022-02-17T07:14:04.488169Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• پردازش داده‌ها

\n

ابتدا باید داده‌های مورد نیاز برای کار را خواند. در این رقابت علاوه بر تصاویر JPG از قالب TF هم استفاده می‌شود. TF یک قالب یا فرمت ساده برای ذخیره سازی دنباله‌ای از رکوردهای باینری است.

\n

GCS حافظه ابری گوگل است که داده‌ها بر روی آن ذخیره شده است. برای دسترسی به این داده‌ها، باید کلید امنیتی از حساب کولب در گوگل، در Add-ons نوت‌بوک فعلی این رقابت مقدادهی شود.

","metadata":{}},{"cell_type":"code","source":"GCS_PATH = KaggleDatasets().get_gcs_path()","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:04.491161Z","iopub.execute_input":"2022-02-17T07:14:04.491932Z","iopub.status.idle":"2022-02-17T07:14:04.975268Z","shell.execute_reply.started":"2022-02-17T07:14:04.491887Z","shell.execute_reply":"2022-02-17T07:14:04.97455Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

\n

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

","metadata":{}},{"cell_type":"code","source":"from kaggle_secrets import UserSecretsClient\nuser_secrets = UserSecretsClient()\nuser_credential = user_secrets.get_gcloud_credential()\nuser_secrets.set_tensorflow_credential(user_credential)","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:04.976421Z","iopub.execute_input":"2022-02-17T07:14:04.976783Z","iopub.status.idle":"2022-02-17T07:14:05.176857Z","shell.execute_reply.started":"2022-02-17T07:14:04.976754Z","shell.execute_reply":"2022-02-17T07:14:05.176019Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

\n

همانطور که گفتیم داده‌ها از رکوردهای TF خوانده می‌شوند

","metadata":{}},{"cell_type":"code","source":"MONET_FILENAMES = tf.io.gfile.glob(str(GCS_PATH + '/monet_tfrec/*.tfrec'))\nprint('Monet TFRecord Files:', len(MONET_FILENAMES))\n\nPHOTO_FILENAMES = tf.io.gfile.glob(str(GCS_PATH + '/photo_tfrec/*.tfrec'))\nprint('Photo TFRecord Files:', len(PHOTO_FILENAMES))","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:05.178349Z","iopub.execute_input":"2022-02-17T07:14:05.179295Z","iopub.status.idle":"2022-02-17T07:14:05.3371Z","shell.execute_reply.started":"2022-02-17T07:14:05.179247Z","shell.execute_reply":"2022-02-17T07:14:05.336372Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• پیش‌پردازش

\n

تصاویر ارائه شده برای این رقابت، در سایز 256x256 هستند و نیازی به تغییر سایز آن‌ها نیست. همچنین این تصاویر در مد رنگی RGB قرار دارند، بنابراین کانال اولیه آن‌ها 3 است. همچنین باید تصاویر را نرمال کنیم، یعنی پیکسل‌های تصویر را به بازه [1, 1-] ببرسم.

\n

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

","metadata":{}},{"cell_type":"code","source":"IMAGE_SIZE = [256, 256]\n\ndef decode_image(image):\n image = tf.image.decode_jpeg(image, channels=3)\n image = (tf.cast(image, tf.float32) / 127.5) - 1\n image = tf.reshape(image, [*IMAGE_SIZE, 3])\n return image\n\ndef read_tfrecord(example):\n tfrecord_format = {\n \"image_name\": tf.io.FixedLenFeature([], tf.string),\n \"image\": tf.io.FixedLenFeature([], tf.string),\n \"target\": tf.io.FixedLenFeature([], tf.string)\n }\n example = tf.io.parse_single_example(example, tfrecord_format)\n image = decode_image(example['image'])\n return image","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:05.339878Z","iopub.execute_input":"2022-02-17T07:14:05.340425Z","iopub.status.idle":"2022-02-17T07:14:05.349662Z","shell.execute_reply.started":"2022-02-17T07:14:05.340381Z","shell.execute_reply":"2022-02-17T07:14:05.348636Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

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

\n

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

","metadata":{}},{"cell_type":"code","source":"def load_dataset(filenames, labeled=True, ordered=False):\n dataset = tf.data.TFRecordDataset(filenames)\n dataset = dataset.map(read_tfrecord, num_parallel_calls=AUTOTUNE)\n return dataset","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:05.351043Z","iopub.execute_input":"2022-02-17T07:14:05.351294Z","iopub.status.idle":"2022-02-17T07:14:05.364518Z","shell.execute_reply.started":"2022-02-17T07:14:05.351266Z","shell.execute_reply":"2022-02-17T07:14:05.363572Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

\n

استفاده از تابع ایجاد شده در بالا برای خواندن تصاویر و نقاشی‌ها

","metadata":{}},{"cell_type":"code","source":"monet_ds = load_dataset(MONET_FILENAMES, labeled=True).batch(1)\nphoto_ds = load_dataset(PHOTO_FILENAMES, labeled=True).batch(1)","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:05.365821Z","iopub.execute_input":"2022-02-17T07:14:05.366084Z","iopub.status.idle":"2022-02-17T07:14:06.228256Z","shell.execute_reply.started":"2022-02-17T07:14:05.366046Z","shell.execute_reply":"2022-02-17T07:14:06.227327Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• نمایش نمونه‌ها

\n

جداکردن نمونه‌هایی برای نمایش تصاویر و نقاشی‌ها و قراردادن آن‌ها در example_monet و example_photo

","metadata":{}},{"cell_type":"code","source":"example_monet = next(iter(monet_ds))\nexample_photo = next(iter(photo_ds))","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:06.229532Z","iopub.execute_input":"2022-02-17T07:14:06.229849Z","iopub.status.idle":"2022-02-17T07:14:06.327252Z","shell.execute_reply.started":"2022-02-17T07:14:06.229816Z","shell.execute_reply":"2022-02-17T07:14:06.326387Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

\n

با استفاده از plt تعدادی از عکس‌ها و نقاشی‌ها را نمایش می‌دهیم. عدد 121 در  plt.subplt(121) نمایش دهنده تعداد سطر، ستون و ایندکس شروع نمایش است. برای اطلاعات بیشتر اینجا را ببینید.

","metadata":{}},{"cell_type":"code","source":"plt.subplot(121)\nplt.title('Photo')\nplt.imshow(example_photo[0] * 0.5 + 0.5)\n\nplt.subplot(122)\nplt.title('Monet')\nplt.imshow(example_monet[0] * 0.5 + 0.5)","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:06.329185Z","iopub.execute_input":"2022-02-17T07:14:06.329462Z","iopub.status.idle":"2022-02-17T07:14:06.722348Z","shell.execute_reply.started":"2022-02-17T07:14:06.329432Z","shell.execute_reply":"2022-02-17T07:14:06.721266Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• ساخت تولیدکننده

\n

همانطور که گفتیم، در ساخت تولیدکننده از معماری U-Net در گن چرخشی خود استفاده می‌کنیم. برای ایجاد تولیدکننده، اول می‌بایست فرآیند downsample و upsample را تعریف کنیم.

\n

• ایجاد تابع کاهش سایز:

\n

 ابتدا با initializer یک حالت شروع تصادفی برای کرنل خود تعیین می‌کنیم. اطلاعات بیشتر در اینجا. در ادامه با gamma_init نحوه وزن دهی گاما در نرمال کردن را تصادفی تعیین می‌کنیم. اطلاعات بیشتر در اینجا و اینجا

\n

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

\n

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

\n

با use_bias=false استفاده از بایاس را غیرفعال می‌کنیم. در مواقعی که نرمال‌سازی گروهی یا نمونه‌ای داریم، می‌توان بایاس را در نظر نگرفت، به این دلیل که تاثیر آن در لایه‌های بعد نادیده گرفته می‌شود و عملا استفاده از آن بی‌فایده است. برای اطلاعات بیشتر اینجا

\n

در آخر یک تابع فعال ساز لیکی‌رلو هم بر روی آن اعمال می‌کنیم.

\n

برای استفاده از نرمال‌سازی نمونه‌ای باید از tfa یا TensorFlow Add-ons استفاده کنیم به این دلیل که این نرمال‌سازی در TensorFlow عادی وجود ندارد.

","metadata":{}},{"cell_type":"code","source":"OUTPUT_CHANNELS = 3\n\ndef downsample(filters, size, apply_instancenorm=True):\n initializer = tf.random_normal_initializer(0., 0.02)\n gamma_init = keras.initializers.RandomNormal(mean=0.0, stddev=0.02)\n\n result = keras.Sequential()\n result.add(layers.Conv2D(filters, size, strides=2, padding='same',\n kernel_initializer=initializer, use_bias=False))\n\n if apply_instancenorm:\n result.add(tfa.layers.InstanceNormalization(gamma_initializer=gamma_init))\n\n result.add(layers.LeakyReLU())\n\n return result","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:06.723696Z","iopub.execute_input":"2022-02-17T07:14:06.723949Z","iopub.status.idle":"2022-02-17T07:14:06.733708Z","shell.execute_reply.started":"2022-02-17T07:14:06.72392Z","shell.execute_reply":"2022-02-17T07:14:06.732685Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• ایجاد تابع افزایش سایز:

\n

در ادامه تابعupsample کردن را ایجاد می‌کنیم. این تابع برخلاف downsample ابعاد و فیلترهای تصاویر را اضافه می‌کند. برای upsample همانطور که قبلا گفتیم از ماتریس کانولوشن ترانهاده استفاده می‌کنیم.

\n

می‌توانیم dropout بزنیم و در صورت استفاده نرخ آن 0.5 خواهد بود.

","metadata":{}},{"cell_type":"code","source":"def upsample(filters, size, apply_dropout=False):\n initializer = tf.random_normal_initializer(0., 0.02)\n gamma_init = keras.initializers.RandomNormal(mean=0.0, stddev=0.02)\n\n result = keras.Sequential()\n result.add(layers.Conv2DTranspose(filters, size, strides=2,\n padding='same',\n kernel_initializer=initializer,\n use_bias=False))\n\n result.add(tfa.layers.InstanceNormalization(gamma_initializer=gamma_init))\n\n if apply_dropout:\n result.add(layers.Dropout(0.5))\n\n result.add(layers.ReLU())\n\n return result","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:06.735194Z","iopub.execute_input":"2022-02-17T07:14:06.73545Z","iopub.status.idle":"2022-02-17T07:14:06.74379Z","shell.execute_reply.started":"2022-02-17T07:14:06.735421Z","shell.execute_reply":"2022-02-17T07:14:06.74323Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• ساخت تولیدکننده:

\n

بعد از تعریف فرآیندهای کوچک‌سازی و بزرگ‌سازی ورودی‌ها که در تولیدکننده نیاز است، به سراغ ساخت تولیدکننده خود می‌رویم.

\n

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

\n

\n

در این جا خروجی لایه downsample به ورودی لایه upsample به صورت متقارن برده می‌شود.

","metadata":{}},{"cell_type":"code","source":"def Generator():\n inputs = layers.Input(shape=[256,256,3])\n\n # bs = batch size\n down_stack = [\n downsample(64, 4, apply_instancenorm=False), # (bs, 128, 128, 64)\n downsample(128, 4), # (bs, 64, 64, 128)\n downsample(256, 4), # (bs, 32, 32, 256)\n downsample(512, 4), # (bs, 16, 16, 512)\n downsample(512, 4), # (bs, 8, 8, 512)\n downsample(512, 4), # (bs, 4, 4, 512)\n downsample(512, 4), # (bs, 2, 2, 512)\n downsample(512, 4), # (bs, 1, 1, 512)\n ]\n\n up_stack = [\n upsample(512, 4, apply_dropout=True), # (bs, 2, 2, 1024)\n upsample(512, 4, apply_dropout=True), # (bs, 4, 4, 1024)\n upsample(512, 4, apply_dropout=True), # (bs, 8, 8, 1024)\n upsample(512, 4), # (bs, 16, 16, 1024)\n upsample(256, 4), # (bs, 32, 32, 512)\n upsample(128, 4), # (bs, 64, 64, 256)\n upsample(64, 4), # (bs, 128, 128, 128)\n ]\n\n initializer = tf.random_normal_initializer(0., 0.02)\n last = layers.Conv2DTranspose(OUTPUT_CHANNELS, 4,\n strides=2,\n padding='same',\n kernel_initializer=initializer,\n activation='tanh') # (bs, 256, 256, 3)\n\n x = inputs\n\n # Downsampling through the model\n skips = []\n for down in down_stack:\n x = down(x)\n skips.append(x)\n\n skips = reversed(skips[:-1])\n\n # Upsampling and establishing the skip connections\n for up, skip in zip(up_stack, skips):\n x = up(x)\n x = layers.Concatenate()([x, skip])\n\n x = last(x)\n\n return keras.Model(inputs=inputs, outputs=x)","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:06.744941Z","iopub.execute_input":"2022-02-17T07:14:06.745433Z","iopub.status.idle":"2022-02-17T07:14:06.757661Z","shell.execute_reply.started":"2022-02-17T07:14:06.745397Z","shell.execute_reply":"2022-02-17T07:14:06.75677Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• ساخت تمایزدهنده:

\n

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

\n

\n

در این جا هم یک انکودر داریم که downsample می‌کند و از لایه‌های در ادامه تشکیل شده است: لایه کانولوشنی / لایه نرمال‌سازی نمونه‌ایی که به بلاک اول اعمال نمی‌شود / لایه لیکی‌رلو

\n

خروجی در اینجا یک تیکه 30x30 است از تصویر ورودی است.

","metadata":{}},{"cell_type":"code","source":"def Discriminator():\n initializer = tf.random_normal_initializer(0., 0.02)\n gamma_init = keras.initializers.RandomNormal(mean=0.0, stddev=0.02)\n\n inp = layers.Input(shape=[256, 256, 3], name='input_image')\n\n x = inp\n\n down1 = downsample(64, 4, False)(x) # (bs, 128, 128, 64)\n down2 = downsample(128, 4)(down1) # (bs, 64, 64, 128)\n down3 = downsample(256, 4)(down2) # (bs, 32, 32, 256)\n\n zero_pad1 = layers.ZeroPadding2D()(down3) # (bs, 34, 34, 256)\n conv = layers.Conv2D(512, 4, strides=1,\n kernel_initializer=initializer,\n use_bias=False)(zero_pad1) # (bs, 31, 31, 512)\n\n norm1 = tfa.layers.InstanceNormalization(gamma_initializer=gamma_init)(conv)\n\n leaky_relu = layers.LeakyReLU()(norm1)\n\n zero_pad2 = layers.ZeroPadding2D()(leaky_relu) # (bs, 33, 33, 512)\n\n last = layers.Conv2D(1, 4, strides=1,\n kernel_initializer=initializer)(zero_pad2) # (bs, 30, 30, 1)\n\n return tf.keras.Model(inputs=inp, outputs=last)","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:06.759183Z","iopub.execute_input":"2022-02-17T07:14:06.759512Z","iopub.status.idle":"2022-02-17T07:14:06.774091Z","shell.execute_reply.started":"2022-02-17T07:14:06.759475Z","shell.execute_reply":"2022-02-17T07:14:06.773127Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• تعیین تولیدکننده‌ها و تمیزدهنده‌ها:

\n

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

\n\n\n

monet_generator یاد می‌گیرد که چگونه تصاویر را به نقاشی مونه تبدیل کند.

\n

photo_generator یاد می‌گیرد که چگونه نقاشی‌ مونه را به تصاویر تبدیل کند.

\n

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

\n\n\n

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

\n

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

\n

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

","metadata":{}},{"cell_type":"code","source":"with strategy.scope():\n monet_generator = Generator() # transforms photos to Monet-esque paintings\n photo_generator = Generator() # transforms Monet paintings to be more like photos\n\n monet_discriminator = Discriminator() # differentiates real Monet paintings and generated Monet paintings\n photo_discriminator = Discriminator() # differentiates real photos and generated photos","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:06.776985Z","iopub.execute_input":"2022-02-17T07:14:06.777273Z","iopub.status.idle":"2022-02-17T07:14:15.833852Z","shell.execute_reply.started":"2022-02-17T07:14:06.777239Z","shell.execute_reply":"2022-02-17T07:14:15.833026Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tf.keras.utils.plot_model(monet_generator, show_shapes=True, dpi=64)","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:15.835333Z","iopub.execute_input":"2022-02-17T07:14:15.835557Z","iopub.status.idle":"2022-02-17T07:14:16.987069Z","shell.execute_reply.started":"2022-02-17T07:14:15.83553Z","shell.execute_reply":"2022-02-17T07:14:16.9863Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tf.keras.utils.plot_model(monet_discriminator, show_shapes=True, dpi=64)","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:16.988383Z","iopub.execute_input":"2022-02-17T07:14:16.988733Z","iopub.status.idle":"2022-02-17T07:14:17.145402Z","shell.execute_reply.started":"2022-02-17T07:14:16.988702Z","shell.execute_reply":"2022-02-17T07:14:17.144093Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

با توجه به این که هنوز تولیدکننده‌های ما آموزش ندیده‌اند، تصاویر تولیدی آن‌ها کیفیت خاصی ندارد که در ادامه می‌بینیم.

","metadata":{}},{"cell_type":"code","source":"to_monet = monet_generator(example_photo)\n\nplt.subplot(1, 2, 1)\nplt.title(\"Original Photo\")\nplt.imshow(example_photo[0] * 0.5 + 0.5)\n\nplt.subplot(1, 2, 2)\nplt.title(\"Monet-esque Photo\")\nplt.imshow(to_monet[0] * 0.5 + 0.5)\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:17.147278Z","iopub.execute_input":"2022-02-17T07:14:17.147523Z","iopub.status.idle":"2022-02-17T07:14:17.811387Z","shell.execute_reply.started":"2022-02-17T07:14:17.147493Z","shell.execute_reply":"2022-02-17T07:14:17.810525Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• ساخت مدل چرخشی

\n

کلاس CycleGan را که از keras.model به ارث برده شده است را ایجاد می‌کنیم. با این کار در انتها با fit مدل را آموزش می‌دهیم. با این روش استفاده از ظرفیت TPU بهینه می‌شود.

\n

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

\n

چنین تعریفی برای نقاشی‌ها هم صدق می‌کند.

\n

خطاهای آموزش در مرحله بعد تعریف می‌شوند.

\n

در اینجا دو تا مفهوم استفاده شده است:

\n\n\n

یکی از اصول اساسی کراس، افشای تدریجی پیچیدگی‌ها (progressive disclosure of complexity) است. باید بتوانید به صورت تدریجی وارد جریان‌های کاری سطح پایین‌تر بشوید. اگر عملکرد سطح بالای موجود دقیقاً با نیاز مورد استفاده شما تطابق ندارد، نباید از صخره سقوط کنید! باید بتوانید کنترل بیشتری بر روی جزئیات کوچک به دست آورید و در عین حال میزان مناسبی از راحتی در سطح بالاتر را حفظ کنید. طبق این اصل، شما همیشه باید قادر باشید تا به سطوح کاری زیرین کتابخانه به شیوه تدریجی دسترسی پیدا کنید. در واقع اگر مورد کار شما دقیقاً با تعریف‌های پایه‌ای کتابخانه نیست، برای رفع نیاز خود شما نباید از قله انتزاع به دره پیچیدگی‌های سطح پایین سقوط کنید. شما در هر مرحله باید بتوانید به آن مقداری از جزئیات که برای تغییر نیاز دارید دسترسی داشته باشید.

\n

وقتی که می‌خواهید ()fit را برای خودتان سفارشی کنید، باید مراحل آموزشی تابع کلاس Model را باطل و یا بهتر بگوییم بازنویسی کنید تا بتوانید با فراخوانی ()fit به مانند قبل، الگوریتم‌های آموزشی خود را اجرا کنید. شما در عمل باید این تابع از کلاس Model را که مسئول اجرای قدم‌های آموزش مدل است را بازنویسی کنید. این تابع برای دسته یا batch از داده صدا زده می‌شود. پس از بازنویسی این تابع از کلاس Model، این تابع می‌تواند به طور معمول با کد شما صدا زده شود تا الگوریتم شخصی شما را روی داده اجرا کند تا آموزش شبکه انجام شود. اطلاعات بیشتر در اینجا

\n

وقتی که نیاز داریم حلقه‌های آموزش را از پایه و صفر بنویسیم، با استفاده از Gradient.Tape می‌توانیم کنترل هر چیز جزئی را هم در اختیار داشته باشیم. در اینجا یک الگوریتم آموزشی ایجاد کرده‌ایم اما نیاز داریم که از ویژگی‌هایی که fit به ما ارائه می‌کند هم بهره‌مند شویم، ویژگی‌هایی مانند callbacks و built-in distribution support و...

\n

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

\n

lamdba_cycle=10 در اینجا یک هایپرپامتر است و با استفاده از آن خطای ثبات چرخش را وزن‌دهی می‌کنیم و در ابتدای کار برابر 10 قرار می‌دهیم.برای اطلاعات بیشتر در اینجا و اینجا

\n

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

\n

\n

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

","metadata":{}},{"cell_type":"code","source":"class CycleGan(keras.Model):\n def __init__(\n self,\n monet_generator,\n photo_generator,\n monet_discriminator,\n photo_discriminator,\n lambda_cycle=10,\n ):\n super(CycleGan, self).__init__()\n self.m_gen = monet_generator\n self.p_gen = photo_generator\n self.m_disc = monet_discriminator\n self.p_disc = photo_discriminator\n self.lambda_cycle = lambda_cycle\n \n def compile(\n self,\n m_gen_optimizer,\n p_gen_optimizer,\n m_disc_optimizer,\n p_disc_optimizer,\n gen_loss_fn,\n disc_loss_fn,\n cycle_loss_fn,\n identity_loss_fn\n ):\n super(CycleGan, self).compile()\n self.m_gen_optimizer = m_gen_optimizer\n self.p_gen_optimizer = p_gen_optimizer\n self.m_disc_optimizer = m_disc_optimizer\n self.p_disc_optimizer = p_disc_optimizer\n self.gen_loss_fn = gen_loss_fn\n self.disc_loss_fn = disc_loss_fn\n self.cycle_loss_fn = cycle_loss_fn\n self.identity_loss_fn = identity_loss_fn\n \n def train_step(self, batch_data):\n real_monet, real_photo = batch_data\n \n with tf.GradientTape(persistent=True) as tape:\n # photo to monet back to photo\n fake_monet = self.m_gen(real_photo, training=True)\n cycled_photo = self.p_gen(fake_monet, training=True)\n\n # monet to photo back to monet\n fake_photo = self.p_gen(real_monet, training=True)\n cycled_monet = self.m_gen(fake_photo, training=True)\n\n # generating itself\n same_monet = self.m_gen(real_monet, training=True)\n same_photo = self.p_gen(real_photo, training=True)\n\n # discriminator used to check, inputing real images\n disc_real_monet = self.m_disc(real_monet, training=True)\n disc_real_photo = self.p_disc(real_photo, training=True)\n\n # discriminator used to check, inputing fake images\n disc_fake_monet = self.m_disc(fake_monet, training=True)\n disc_fake_photo = self.p_disc(fake_photo, training=True)\n\n # evaluates generator loss\n monet_gen_loss = self.gen_loss_fn(disc_fake_monet)\n photo_gen_loss = self.gen_loss_fn(disc_fake_photo)\n\n # evaluates total cycle consistency loss\n total_cycle_loss = self.cycle_loss_fn(real_monet, cycled_monet, self.lambda_cycle) + self.cycle_loss_fn(real_photo, cycled_photo, self.lambda_cycle)\n\n # evaluates total generator loss\n total_monet_gen_loss = monet_gen_loss + total_cycle_loss + self.identity_loss_fn(real_monet, same_monet, self.lambda_cycle)\n total_photo_gen_loss = photo_gen_loss + total_cycle_loss + self.identity_loss_fn(real_photo, same_photo, self.lambda_cycle)\n\n # evaluates discriminator loss\n monet_disc_loss = self.disc_loss_fn(disc_real_monet, disc_fake_monet)\n photo_disc_loss = self.disc_loss_fn(disc_real_photo, disc_fake_photo)\n\n # Calculate the gradients for generator and discriminator\n monet_generator_gradients = tape.gradient(total_monet_gen_loss,\n self.m_gen.trainable_variables)\n photo_generator_gradients = tape.gradient(total_photo_gen_loss,\n self.p_gen.trainable_variables)\n\n monet_discriminator_gradients = tape.gradient(monet_disc_loss,\n self.m_disc.trainable_variables)\n photo_discriminator_gradients = tape.gradient(photo_disc_loss,\n self.p_disc.trainable_variables)\n\n # Apply the gradients to the optimizer\n self.m_gen_optimizer.apply_gradients(zip(monet_generator_gradients,\n self.m_gen.trainable_variables))\n\n self.p_gen_optimizer.apply_gradients(zip(photo_generator_gradients,\n self.p_gen.trainable_variables))\n\n self.m_disc_optimizer.apply_gradients(zip(monet_discriminator_gradients,\n self.m_disc.trainable_variables))\n\n self.p_disc_optimizer.apply_gradients(zip(photo_discriminator_gradients,\n self.p_disc.trainable_variables))\n \n return {\n \"monet_gen_loss\": total_monet_gen_loss,\n \"photo_gen_loss\": total_photo_gen_loss,\n \"monet_disc_loss\": monet_disc_loss,\n \"photo_disc_loss\": photo_disc_loss\n }","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:17.812847Z","iopub.execute_input":"2022-02-17T07:14:17.813095Z","iopub.status.idle":"2022-02-17T07:14:17.834301Z","shell.execute_reply.started":"2022-02-17T07:14:17.813067Z","shell.execute_reply":"2022-02-17T07:14:17.833254Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• محاسبه توابع خطا

\n

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

\n

در محاسبه خطای تولیدکننده و تمایزدهنده از BinaryCrossentropy استفاده می‌شود. 

\n

تابع خطای تمایزدهنده 2 ورودی دریافت می‌کند:

\n\n\n

در محاسبه خطای نهایی دو عنصر تاثیر می‌گذارند:

\n\n\n

بنابراین خطای نهایی در تمایزدهنده‌ها، نصف مجموع خطای تشخیص نمونه‌های واقعی و خطای تشخیص نمونه‌های تولیدشده می‌باشد.

","metadata":{}},{"cell_type":"code","source":"with strategy.scope():\n def discriminator_loss(real, generated):\n real_loss = tf.keras.losses.BinaryCrossentropy(from_logits=True, reduction=tf.keras.losses.Reduction.NONE)(tf.ones_like(real), real)\n\n generated_loss = tf.keras.losses.BinaryCrossentropy(from_logits=True, reduction=tf.keras.losses.Reduction.NONE)(tf.zeros_like(generated), generated)\n\n total_disc_loss = real_loss + generated_loss\n\n return total_disc_loss * 0.5","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:17.835452Z","iopub.execute_input":"2022-02-17T07:14:17.835971Z","iopub.status.idle":"2022-02-17T07:14:17.851755Z","shell.execute_reply.started":"2022-02-17T07:14:17.835939Z","shell.execute_reply":"2022-02-17T07:14:17.85069Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• محاسبه خطای تولید کننده:

\n

برای محاسبه خطای تولیدکننده باید به سه مفهوم توجه کنیم:

\n\n\n

در محاسبه خطای حریف باید این گونه عمل کنیم:

\n\n\n

تولیدکننده زمانی می‌فهمد که خوب عمل کرده است که تمایزدهنده به دردسر افتاده باشد و تصویری را تقلبی تشخیص ندهد که این تصویر تقلبی بتواند به عنوان ورودی برای تابع تشخیص خطا در تولیدکننده استفاده شود، در واقع برای همه ورودی‌ها، واقعی را تشخیص دهد!

","metadata":{}},{"cell_type":"code","source":"with strategy.scope():\n def generator_loss(generated):\n return tf.keras.losses.BinaryCrossentropy(from_logits=True, reduction=tf.keras.losses.Reduction.NONE)(tf.ones_like(generated), generated)","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:17.853452Z","iopub.execute_input":"2022-02-17T07:14:17.853718Z","iopub.status.idle":"2022-02-17T07:14:17.864173Z","shell.execute_reply.started":"2022-02-17T07:14:17.853683Z","shell.execute_reply":"2022-02-17T07:14:17.863051Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• خطای ثبات چرخش در تولیدکننده:

\n

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

\n\n
\n
\n
\n
این چرخه شامل مراحل زیر است:\n
    \n \t
  • یک تصویر ورودی بوسیله یک تولیدکننده مونه به یک نقاشی تقلبی تبدیل می‌شود و این نقاشی تقلبی به عنوان یک ورودی برای تولیدکننده تصویر استفاده شده و این تولیدکننده تصویر آن را تبدیل به یک تصویر می‌کند که آن را تصویر دوار می‌گوییم.\n
      \n \t
    • Input Photo -> G_MONET -> Fake Monet -> G_PHOTO -> Cycle Photo
      • \n
    \n
    • \n \t
  • یک نقاشی ورودی بوسیله یک تولیدکننده تصویر به یک تصویر تقلبی تبدیل می‌شود و این تصویر تقلبی به عنوان یک ورودی برای تولیدکننده نقاشی استفاده شده و این تولیدکننده نقاشی آن را تبدیل به یک نقاشی می‌کند که آن را نقاشی دوار می‌گوییم.\n
      \n \t
    • Input Monet -> G_PHOTO -> Fake Photo -> G_MONET -> Cycle Monet
      • \n
    \n
    • \n
\nدر واقع تصویر یا نقاشی دوار در انتهای هر مرحله، باید در دامنه ورودی باشد و به دنبال به دست آوردن خطای این تبدیل می‌باشیم که متوجه شویم تولیدکننده‌ها تا چه مقدار توانستند ویژگی‌ها را برای تبدیل دامنه‌ها به یکدیگر بیابند. پس برای محاسبه خطای ثبات چرخش، دو چیز باید اندازه گرفته شوند:\n
    \n \t
  • \n
      \n \t
    • میانگین خطای مطلق برای تصاویر، که از محاسبه بین تصویر ورودی و تصویر دوار به دست می‌آید.
      • \n \t
    • میانگین خطای مطلق برای نقاشی‌ها، که از محاسبه بین نقاشی ورودی و نقاشی دوار به دست می‌آید.
      • \n
    \n
    • \n
\nخطای چرخشی در نهایت جمع این دو مقدار خواهد بود.\n\n
\n
\n
\n
\n

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

","metadata":{}},{"cell_type":"code","source":"with strategy.scope():\n def calc_cycle_loss(real_image, cycled_image, LAMBDA):\n loss1 = tf.reduce_mean(tf.abs(real_image - cycled_image))\n\n return LAMBDA * loss1","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:17.865333Z","iopub.execute_input":"2022-02-17T07:14:17.865585Z","iopub.status.idle":"2022-02-17T07:14:17.878155Z","shell.execute_reply.started":"2022-02-17T07:14:17.865553Z","shell.execute_reply":"2022-02-17T07:14:17.877267Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• خطای تشخیص هویت:

\n

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

\n

بنابراین خطای تشخیص هویت بر اساس شباهت تصویر خروجی به ورودی عمل می‌کند.

\n\n
\n
\n
\n
\n
    \n \t
  • این تابع 2 ورودی دریافت می‌کند، تصویر اصلی و تصویر تولید شده از روی تصویر اصلی که در همان دامنه تصویر اصلی است و باید تا حد ممکن به آن شبیه باشد.\n
      \n \t
    • برای خطای تولیدکننده مونه، مونه تولید شده و مونه ورودی محاسبه می‌شوند.
      • \n \t
    • برای خطای تولیدکننده تصویر، تصویر تولید شده و تصویر ورودی محاسبه می‌شوند.
      • \n
    \n
    • \n
\n

خطا در نهایت میانگین خطای مطلق بین نمونه تولید شده بوسیله تولیدکننده و نمونه واقعی خواهد بود.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
    \n \t
  • \n
\n
\n
\n
\n
","metadata":{}},{"cell_type":"code","source":"with strategy.scope():\n def identity_loss(real_image, same_image, LAMBDA):\n loss = tf.reduce_mean(tf.abs(real_image - same_image))\n return LAMBDA * 0.5 * loss","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:17.879687Z","iopub.execute_input":"2022-02-17T07:14:17.879933Z","iopub.status.idle":"2022-02-17T07:14:17.891487Z","shell.execute_reply.started":"2022-02-17T07:14:17.879906Z","shell.execute_reply":"2022-02-17T07:14:17.890594Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• آموزش گن‌چرشی

\n

نوبت به آموزش مدل رسیده است. در ابتدا بهینه‌سازها یا optimizers را برای تولیدکننده‌ها و تمایزدهنده‌ها تعیین می‌کنیم. برای بهینه‌ساز از Adam و نرخ یادیگیری 0.0002 استفاده می‌کنیم. Adam بهترین الگوریتم بهینه‌سازی است. با Adam می‌توانید آموزش شبکه عصبی را در زمان کمتر و کارایی بالاتر انجام دهید. این روش بر اساس تکانه‌ها عمل می‌کند که beta_1 تکانه اول است که در اینجا 0.5 تنظیم شده است.

","metadata":{}},{"cell_type":"code","source":"with strategy.scope():\n monet_generator_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5)\n photo_generator_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5)\n\n monet_discriminator_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5)\n photo_discriminator_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5)","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:17.893047Z","iopub.execute_input":"2022-02-17T07:14:17.89339Z","iopub.status.idle":"2022-02-17T07:14:17.9058Z","shell.execute_reply.started":"2022-02-17T07:14:17.893347Z","shell.execute_reply":"2022-02-17T07:14:17.905151Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

یک گن‌چرخشی ساخته و مدل را کامپایل می‌کنیم.

","metadata":{}},{"cell_type":"code","source":"with strategy.scope():\n cycle_gan_model = CycleGan(\n monet_generator, photo_generator, monet_discriminator, photo_discriminator\n )\n\n cycle_gan_model.compile(\n m_gen_optimizer = monet_generator_optimizer,\n p_gen_optimizer = photo_generator_optimizer,\n m_disc_optimizer = monet_discriminator_optimizer,\n p_disc_optimizer = photo_discriminator_optimizer,\n gen_loss_fn = generator_loss,\n disc_loss_fn = discriminator_loss,\n cycle_loss_fn = calc_cycle_loss,\n identity_loss_fn = identity_loss\n )","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:17.907321Z","iopub.execute_input":"2022-02-17T07:14:17.907668Z","iopub.status.idle":"2022-02-17T07:14:17.974817Z","shell.execute_reply.started":"2022-02-17T07:14:17.907625Z","shell.execute_reply":"2022-02-17T07:14:17.973909Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

با استفاده از fit مدل را آموزش می‌دهیم. تعداد دفعات آموزش را 25 بار قرار می‌دهیم.

","metadata":{}},{"cell_type":"code","source":"cycle_gan_model.fit(\n tf.data.Dataset.zip((monet_ds, photo_ds)),\n epochs=5\n)","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:14:17.975983Z","iopub.execute_input":"2022-02-17T07:14:17.976319Z","iopub.status.idle":"2022-02-17T07:31:48.023663Z","shell.execute_reply.started":"2022-02-17T07:14:17.976286Z","shell.execute_reply":"2022-02-17T07:31:48.022622Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• نمایش تصاویر تولیدی

\n

نقاشی‌های تولید شده را مشاهده می‌کنیم.

","metadata":{}},{"cell_type":"code","source":"_, ax = plt.subplots(5, 2, figsize=(12, 12))\nfor i, img in enumerate(photo_ds.take(5)):\n prediction = monet_generator(img, training=False)[0].numpy()\n prediction = (prediction * 127.5 + 127.5).astype(np.uint8)\n img = (img[0] * 127.5 + 127.5).numpy().astype(np.uint8)\n\n ax[i, 0].imshow(img)\n ax[i, 1].imshow(prediction)\n ax[i, 0].set_title(\"Input Photo\")\n ax[i, 1].set_title(\"Monet-esque\")\n ax[i, 0].axis(\"off\")\n ax[i, 1].axis(\"off\")\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2022-02-17T07:31:48.025508Z","iopub.execute_input":"2022-02-17T07:31:48.025759Z","iopub.status.idle":"2022-02-17T07:31:50.17691Z","shell.execute_reply.started":"2022-02-17T07:31:48.02573Z","shell.execute_reply":"2022-02-17T07:31:50.176148Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• تولید فایل خروجی

","metadata":{}},{"cell_type":"code","source":"import PIL\n! mkdir ../images","metadata":{"execution":{"iopub.status.busy":"2022-02-17T08:08:27.745502Z","iopub.execute_input":"2022-02-17T08:08:27.745859Z","iopub.status.idle":"2022-02-17T08:08:28.549685Z","shell.execute_reply.started":"2022-02-17T08:08:27.745827Z","shell.execute_reply":"2022-02-17T08:08:28.548863Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"i = 1\nfor img in photo_ds:\n prediction = monet_generator(img, training=False)[0].numpy()\n prediction = (prediction * 127.5 + 127.5).astype(np.uint8)\n im = PIL.Image.fromarray(prediction)\n im.save(\"../images/\" + str(i) + \".jpg\")\n i += 1","metadata":{"execution":{"iopub.status.busy":"2022-02-17T08:08:33.744197Z","iopub.execute_input":"2022-02-17T08:08:33.744569Z","iopub.status.idle":"2022-02-17T08:42:08.445363Z","shell.execute_reply.started":"2022-02-17T08:08:33.744533Z","shell.execute_reply":"2022-02-17T08:42:08.444619Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import shutil\nshutil.make_archive(\"/kaggle/working/images\", 'zip', \"/kaggle/images\")","metadata":{"execution":{"iopub.status.busy":"2022-02-17T08:51:39.952708Z","iopub.execute_input":"2022-02-17T08:51:39.953464Z","iopub.status.idle":"2022-02-17T08:51:44.132736Z","shell.execute_reply.started":"2022-02-17T08:51:39.953421Z","shell.execute_reply":"2022-02-17T08:51:44.132004Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"

• بهبودها

\n

با بررسی موارد مشابه کدهای دیگر در این رقابت و هایپرپارامترهای موجود در مسئله، برای بهبود پیشنهادات زیر ارائه می‌شود:

\n\n\n

\n

در نمودار بالا مشاهده می‌کنیم که در یک مونه‌ساز بهینه شده با تقویت داده، نرخ FID در هر مرحله کاهش پیدا می‌کند که در مرحله 13 تقریبا این نرخ ثابت می‌ماند.

\n

\n

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

\n

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

","metadata":{}}]}