forward-forward.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 style=\"direction:rtl; padding-right:25px\">\n",
    "الگوریتم Forward-Forward\n",
    "</h1>\n",
    "\n",
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "۴۰۰۴۲۲۱۱۲\n",
    "<br>\n",
    "پروژه یادگیری ماشین\n",
    "<br>\n",
    "در این پروژه الگوریتم Fowrard-Forward بررسی می‌شود. این الگوریتم در مقاله‌ای به همین نام (۲۰۲۲) از جفری هینتون، از پدرخوانده‌های یادگیری عمیق معرفی شده است. این مقاله از \n",
    "<a href=\"https://www.cs.toronto.edu/~hinton/FFA13.pdf\">اینجا</a>\n",
    " قابل دریافت است. مساله‌ مورد بحث، دسته‌بندی تصاویر یا Image Classification است.\n",
    "</p>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 style=\"direction:rtl; padding-right:25px\">\n",
    "توضیحات تئوری\n",
    "</h2>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 style=\"direction:rtl; padding-right:25px\">\n",
    "روش پایه‌ای: پس‌انتشار خطا (Backpropagation)\n",
    "</h3>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "در سال ۱۹۸۶، جفری هینتون (ایده‌پرداز الگوریتم forward-forward) یکی از مبدعان روش پس‌انتشار برای آموزش شبکه‌های عصبی بود. امروزه، بیشتر روش‌های مبتنی بر یادگیری عمیق از این روش برای آموزش استفاده می‌کنند. ابتدا داده‌ با رویکردی بالا به پایین فرآیند پیش‌رو (Forward Pass) را طی می‌کند. در انتها یک خروجی توسط شبکه تخمین زده می‌شود. سپس، با رویکردی پایین به بالا در فرآیند پس‌انتشار (Backpropagation)، مدل با مقایسه خروجی مدل و مقدار واقعی محاسبه می‌کند که هر پارامتر شبکه چقدر در بروز خطا نقش داشته است. این مهم، با محاسبه مشتقات جزیی تابع خطا نسبت به پارامترهای شبکه صورت می‌گیرد و گرادیان‌ها را با کمک قاعده مشتق زنجیره‌ای از لایه آخر به لایه‌های اول انتشار می‌دهد. سپس با استفاده از این گرادیان‌ها و الگوریتم‌های مبتنی بر گرادیان کاهشی، پارامترهای شبکه را در جهت کاهش خطا تغییر می‌دهیم تا زمانی که به یک کمینه محلی برای تابع خطا برسیم.\n",
    "</p>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![forward-backward](./assets/forwad-vs-backward.png)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![forward-backward](./assets/chain-rule.png)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 style=\"direction:rtl; padding-right:25px\">\n",
    "مشکل پس‌انتشار چیست؟\n",
    "</h3>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "همانطور که اشاره شد، امروزه انتخاب اول برای آموزش مدل‌های یادگیری عمیق استفاده از پس‌انتشار است. اما این روش با وجود کارکرد فوق‌العاده خود، محدودیت‌هایی نیز دارد. در نتیجه نیاز داریم روش‌های جدیدتری را جستجو و بررسی کنیم. از برخی از محدودیت‌های این روش می‌توان موارد زیر را نام برد:\n",
    "<br><br>\n",
    "این روش تفاوت بسیاری با آن چه از مغز می‌دانیم دارد. اتصالات بین نواحی مختلف در سیستم بینایی، با رویکرد پایین به بالای پس‌انتشار هم‌خوانی ندارد. در عوض، سیگنال‌های نورونی در حلقه‌هایی چندین لایه از قشر مغز را طی‌ کرده و سپس به مناطق قبلی باز می‌گردند.\n",
    "<br><br>\n",
    "جدا بودن فرآیند یادگیری (learning) از استنتاج (inference). به طور خاص، پس‌انتشار در طول زمان که به عنوان روشی برای یادگیری دنباله‌ها (seqence) استفاده می‌شود، غیرممکن است. برای تنظیم وزن یک شبکه عصبی، الگوریتم آموزشی باید استنتاج را متوقف کند تا پس‌انتشار انجام شود در صورتی که در دنیای واقعی، مغز یک جریان دائمی از اطلاعات را دریافت می‌کند.\n",
    "<br><br>\n",
    "اگر محاسبات انجام شده در فرآیند پیش‌رو مشتق‌پذیر نباشند یا یک black-box در طول مسیر وجود داشته باشد، استفاده از پس‌انتشار شدنی نیست.\n",
    "<br><br>\n",
    "در غیاب پس انتشار، می توانیم به یادگیری تقویتی (reinforcement learning) متوسل شویم. ایده این است که انحرافات (perturbation) تصادفی در وزن‌ها ایجاد کرده و آن‌ها را با تغییرات حاصل در یک تابع بازده مرتبط کنیم. با این حال، یادگیری تقویتی از واریانس بالایی رنج می‌برد. زمانی که چند متغیر را با هم تغییر دهیم، تعیین نتیجه تغییر یکی از آنها بر روی تابع بازده دشوار است. همچنین آموزش مدل RL هزینه بر است. پس چگونه بر چالش های ذکر شده غلبه کنیم؟\n",
    "</p>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 style=\"direction:rtl; padding-right:25px\">\n",
    "الگوریتم Forward-Forward\n",
    "</h3>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "به طور خلاصه، الگوریتم forward-forward یک فرآیند پیش‌رو (forward pass) و یک فرآیند پس‌انتشار را با دو فرآیند پیش‌رو تعویض می‌کند. این دو گذر مشابه هم هستند اما ۱) روی داده‌های متفاوتی صورت می‌گیرند و ۲) تابع هدف متضاد و متفاوتی دارند.\n",
    "<br><br>\n",
    "مزایا:‌ زمانی که جزییات دقیق محاسبات پیش‌رو ناشناخته باشد، می‌توان از این الگوریتم استفاده کرد. همچنین هنگام کار با داده‌های دنباله‌ای، بدون ذخیره‌سازی فعال‌سازهای نورونی (neural activities) می‌تواند به طور همزمان یادگیری و استنتاج را پیش‌ببرد. در ادامه، این روش در زمان‌هایی که سخت‌افزاری با قدرت پردازش بالا در دسترس نیست می‌تواند بهتر ظاهر شود.\n",
    "<br><br>\n",
    "معایب: در بسیاری از مسائل، از تعمیم‌پذیری خوبی برخوردار نیست به همین دلیل بعید است در مسایلی که محدودیت استفاده از انرژی نداریم، جایگزین پس‌انتشار شود.\n",
    "</p>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "این الگوریتم یک روش حریصانه است که در آن داده‌ها را به دو بخش مثبت و منفی تقسیم می‌کنیم و در دو گذر پیش‌رو به شبکه ورودی می‌دهیم. داده‌های منفی، داده‌هایی با برچسب غلط بوده و داده‌ها مثبت همان داده‌های اصلی هستند. داده‌های منفی را می‌توان به سادگی با انتخاب یک برچسب تصادفی غلط بدست آورد، همچنین از روش‌های مبتنی بر یادگیری می‌توان برای بدست آوردن آن‌ها نیز استفاده کرد. به جای تعریف یک تابع هزینه کلی برای کل شبکه، به ازای هر لایه یک معیار goodness تعریف می‌شود (یک دید local به جای global). در این مقاله، جمع مربعات خروجی‌های تابع فعالساز ReLU به عنوان معیار goodness استفاده شده است. حال هدف این است که وزن‌های هر لایه را به طوری تغییر دهیم که goodness روی داده‌های مثبت بیشتر از یک حد آستانه و goodness روی داده‌های منفی کمتر از آن آستانه باشد. خروجی‌های یک لایه قبل از گذار به لایه بعدی، نرمال‌ می‌شوند، در واقع برای هر لایه یک عملیات layer normalization صورت می‌گیرد. به طور خاص، هدف ما طبقه‌بندی صحیح بردارهای ورودی به عنوان داده‌های مثبت یا داده‌های منفی است با فرض اینکه احتمال مثبت بودن (واقعی بودن) یک بردار ورودی برابر است با:\n",
    "</p>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$p(positive)=\\sigma (\\sum_{j}^{}y_{j}^{2} - \\theta )$$"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "که در آن yj خروجی فعال‌ساز نورون j قبل از نرمال‌سازی لایه است.\n",
    "</p>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 style=\"direction:rtl; padding-right:25px\">\n",
    "پیاده‌سازی کد\n",
    "</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "from tqdm.notebook import tqdm\n",
    "\n",
    "import numpy as np\n",
    "import random\n",
    "from HodaDatasetReader import read_hoda_cdb, read_hoda_dataset\n",
    "from sklearn.model_selection import train_test_split\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "from torch.utils.data import TensorDataset, DataLoader, Dataset\n",
    "from torchvision.datasets import CIFAR10, MNIST\n",
    "from utils.dataset_utils import TrainingDatasetFF\n",
    "from utils.models import FFMultiLayerPerceptron, MultiLayerPerceptron\n",
    "from utils.tools import base_loss, generate_positive_negative_samples_overlay\n",
    "from torchvision.transforms import Compose, ToTensor, Lambda, Normalize"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "در ابتدا تابع تولید نمونه‌های مثبت و منفی را مشخص می‌کنیم. این تابع، برای تولید نمونه منفی، از یک برچسب غلط تصادفی استفاده می‌کند. همچنین از روشی تحت عنوان overlay برای جاگذاری برچسب استفاده می‌کند. بدین صورت که قسمتی کوچک به طول ۱۰ را از گوشه تصویر برای جاگذاری برچسب به صورت One-Hot کنار می‌گذارد.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "pos_gen_fn = generate_positive_negative_samples_overlay\n",
    "\n",
    "device = torch.device(\n",
    "    \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 style=\"direction:rtl; padding-right:25px\">\n",
    "آماده‌سازی داده‌ها\n",
    "</h3>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "در این بخش به آماده‌سازی مجموعه داده مورد استفاده در این مساله می‌پردازیم. این مجموعه که شبیه مجموعه داده MNIST است، از اعداد دست‌نویس فارسی تشکیل شده است و مجموعه داده هدی نام دارد. این مجموعه شامل ۱۰۲ هزار نمونه بوده و اولین بار درسال ۲۰۰۵ در یک پایان‌نامه کارشناسی ارشد معرفی شده است. اطلاعات بیشتر درباره این مجموعه را از <a href=\"http://farsiocr.ir/%D9%85%D8%AC%D9%85%D9%88%D8%B9%D9%87-%D8%AF%D8%A7%D8%AF%D9%87/%D9%85%D8%AC%D9%85%D9%88%D8%B9%D9%87-%D8%A7%D8%B1%D9%82%D8%A7%D9%85-%D8%AF%D8%B3%D8%AA%D9%86%D9%88%DB%8C%D8%B3-%D9%87%D8%AF%DB%8C/\">اینجا</a> بخوانید.\n",
    "<br>\n",
    "همانند مقاله الگوریتم Forward-Forward که نتایج آزمایشات خود را بر روی مجموعه داده MNIST گزارش می‌کند، تمامی پیاده‌سازی‌های آن در اینترنت نیز از همین مجموعه استفاده می‌کنند. به منظور ایجاد تمایز و بررسی یک مجموعه جدیدتر و بومی، این الگوریتم را روی مجموعه داده‌ هدی اجرا می‌کنم. لازم به ذکر است که بر خلاف MNIST که به سادگی از طریق بسته torch قابل دسترسی و استفاده است، کد اکثر مراحل بارگذاری و پیش‌پردازش مجموعه هدی برای torch به صورت دستی نوشته شده است.\n",
    "</p> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax, ay = read_hoda_dataset(\n",
    "    dataset_path=\"dataset/Train 60000.cdb\",\n",
    "    images_height=52,\n",
    "    images_width=52,\n",
    "    one_hot=True,\n",
    "    reshape=False,\n",
    ")\n",
    "\n",
    "bx, by = read_hoda_dataset(\n",
    "    dataset_path=\"dataset/Test 20000.cdb\",\n",
    "    images_height=52,\n",
    "    images_width=52,\n",
    "    one_hot=True,\n",
    "    reshape=False,\n",
    ")\n",
    "\n",
    "cx, cy = read_hoda_dataset(\n",
    "    dataset_path=\"dataset/RemainingSamples.cdb\",\n",
    "    images_height=52,\n",
    "    images_width=52,\n",
    "    one_hot=True,\n",
    "    reshape=False,\n",
    ")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "همانطور که مشاهده می‌کنید، مجموعه شامل ۱۰۲ هزار تصویر سیاه و سفید با ابعاد ۵۲ در ۵۲ است.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We have 102352 samples in total.\n",
      "sample shape: (52, 52, 1)\n"
     ]
    }
   ],
   "source": [
    "X = np.concatenate((ax, bx, cx))\n",
    "y = np.concatenate((ay, by, cy))\n",
    "y_label = np.argmax(y, axis=1)\n",
    "assert len(X) == len(y)\n",
    "print(f\"We have {len(X)} samples in total.\")\n",
    "print(f\"sample shape: {X[0].shape}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "تعدادی از نمونه‌های مجموعه داده را در این قسمت مشاهده می‌کنید.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 504x504 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(7, 7))\n",
    "smpl = random.sample(range(len(X)), 9)\n",
    "for i in range(9):\n",
    "    plt.subplot(330 + 1 + i)\n",
    "    plt.axis(\"off\")\n",
    "    smpl_idx = smpl[i]\n",
    "    plt.imshow(X[smpl_idx, :, :, 0], cmap=\"gray\")\n",
    "    plt.title(np.where(y[smpl_idx] == 1)[0][0])\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "این مجموعه دارای ۱۰ کلاس است. پس از بارگزاری آن، تمامی نمونه‌ها را با هم ادغام کرده، سپس برای حفظ تعادل در کلاس‌ها، از هر کلاس ۱۲٪ داده‌ها را برای test جدا کرده و بقیه را برای train در نظر می‌گیریم.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train samples: 90065 | test samples: 12287\n"
     ]
    }
   ],
   "source": [
    "for cls in range(10):\n",
    "    mask = np.where(y_label == cls)[0]\n",
    "    X_cls = X[mask]\n",
    "    y_cls = y_label[mask]\n",
    "    (\n",
    "        X_cls_train,\n",
    "        X_cls_test,\n",
    "        y_cls_train,\n",
    "        y_cls_test,\n",
    "    ) = train_test_split(\n",
    "        X_cls, y_cls, test_size=0.12, random_state=42\n",
    "    )\n",
    "    if cls == 0:\n",
    "        X_train = X_cls_train\n",
    "        X_test = X_cls_test\n",
    "        y_train = y_cls_train\n",
    "        y_test = y_cls_test\n",
    "        continue\n",
    "    X_train = np.concatenate((X_train, X_cls_train), axis=0)\n",
    "    X_test = np.concatenate((X_test, X_cls_test), axis=0)\n",
    "    y_train = np.concatenate((y_train, y_cls_train), axis=0)\n",
    "    y_test = np.concatenate((y_test, y_cls_test), axis=0)\n",
    "print(\n",
    "    f\"train samples: {len(X_train)} | test samples: {len(X_test)}\"\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyTensorDataset(Dataset):\n",
    "    \"\"\"TensorDataset with support of transforms.\"\"\"\n",
    "\n",
    "    def __init__(self, tensors, transform=None):\n",
    "        assert all(\n",
    "            tensors[0].size(0) == tensor.size(0)\n",
    "            for tensor in tensors\n",
    "        )\n",
    "        self.tensors = tensors\n",
    "        self.transform = transform\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        x = self.tensors[0][index]\n",
    "\n",
    "        if self.transform:\n",
    "            x = self.transform(x)\n",
    "\n",
    "        y = self.tensors[1][index]\n",
    "\n",
    "        return x, y\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.tensors[0].size(0)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "در این بخش تصاویر را flatten می‌کنیم، یعنی آن‌ها را از یک ماتریس دوبعدی به یک بردار تبدیل می‌کنیم. باید دقت کنیم که ابعاد تصویر ۵۲ در ۵۲ است، پس بردار حاصل شامل ۲۷۰۴ مقدار بوده و در نتیجه، لایه اول پرسپترون چندلایه ما باید شامل ۲۰۷۴ نورون باشد.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = MyTensorDataset(\n",
    "    (\n",
    "        torch.Tensor(X_train),\n",
    "        torch.Tensor(y_train).type(torch.LongTensor),\n",
    "    ),\n",
    "    transform=Lambda(lambda x: torch.flatten(x)),\n",
    ")\n",
    "test_dataset = MyTensorDataset(\n",
    "    (\n",
    "        torch.Tensor(X_test),\n",
    "        torch.Tensor(y_test).type(torch.LongTensor),\n",
    "    ),\n",
    "    transform=Lambda(lambda x: torch.flatten(x)),\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_loader = DataLoader(test_dataset, batch_size=1024, shuffle=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "در این بخش یک دیتالودر خاص برای الگوریتم forward-forward می‌سازیم که با هربار فراخوانی، یک نمونه منفی و یک نمونه مثبت به دست می‌دهد.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_loader(dataset, batch_size=1024):\n",
    "    train_loader = DataLoader(\n",
    "        dataset, batch_size=batch_size, shuffle=True\n",
    "    )\n",
    "\n",
    "    train_loader_ff = DataLoader(\n",
    "        TrainingDatasetFF(\n",
    "            pos_gen_fn(X.to(device), Y.to(device), False)\n",
    "            for X, Y in train_loader\n",
    "        ),\n",
    "        batch_size=train_loader.batch_size,\n",
    "        shuffle=True,\n",
    "    )\n",
    "    return train_loader_ff"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 style=\"direction:rtl; padding-right:25px\">\n",
    "فرآیند آموزش\n",
    "</h3>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "ابتدا چند تابع کمکی تعریف می‌کنم. این کار برای کاهش خطوط کد نوشته شده و به کار گیری دوباره یک ماژول به ازای تنظیمات مختلف و مدل‌های مختلف است.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def do_train(train_loader, model, epochs):\n",
    "    for epoch in tqdm(range(epochs)):\n",
    "        for X_pos, Y_neg in train_loader:\n",
    "            layer_losses = model.train_batch(\n",
    "                X_pos, Y_neg, before=False\n",
    "            )\n",
    "            print(\n",
    "                \", \".join(\n",
    "                    map(\n",
    "                        lambda i, l: f\"Layer {i}: {l}\",\n",
    "                        list(range(len(layer_losses))),\n",
    "                        layer_losses,\n",
    "                    )\n",
    "                ),\n",
    "                end=\"\\r\",\n",
    "            )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def do_test(test_dataloader, model):\n",
    "    accuracy = 0\n",
    "    counter = 0\n",
    "    for X_test, Y_test in tqdm(test_dataloader, total=len(test_dataloader)):\n",
    "        X_test = X_test.to(device)\n",
    "        Y_test = Y_test.to(device)\n",
    "\n",
    "        accuracy += (\n",
    "            model.predict_accomulate_goodness(\n",
    "                X_test, pos_gen_fn, n_class=10\n",
    "            )\n",
    "            .eq(Y_test)\n",
    "            .sum()\n",
    "        )\n",
    "        counter += len(X_test)\n",
    "\n",
    "    print(f\"Accuracy on test set: {accuracy/counter:.4%}\")\n",
    "    # print(f\"Test error: {1 - accuracy/counter:.4%}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4 style=\"direction:rtl; padding-right:25px\">\n",
    "آموزش و ارزیابی شبکه به روش Forward-Forward\n",
    "</h4>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "ابتدا یک شبکه به همراه دیتالودر تعریف کرده و کل لایه‌های آن را برای ۶۰ گام آموزش می‌دهیم.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader_ff = get_loader(train_dataset, batch_size=1024)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "mlp_model = FFMultiLayerPerceptron(\n",
    "    hidden_dimensions=[2704, 512, 512],\n",
    "    activation=torch.nn.ReLU(),\n",
    "    optimizer=torch.optim.Adam,\n",
    "    layer_optim_learning_rate=0.09,\n",
    "    threshold=9.0,\n",
    "    loss_fn=base_loss,\n",
    ").to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7e77456463d7482590de47a31e61c0bf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/60 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Layer 0: 0.2822120189666748, Layer 1: 0.427044093608856235\r"
     ]
    }
   ],
   "source": [
    "do_train(train_loader_ff, mlp_model, 60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dcbf0ee8699d478f84cb4ed4e3d7447c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/12 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test set: 97.8107%\n"
     ]
    }
   ],
   "source": [
    "do_test(test_loader, mlp_model)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "حال مدل را برای گام‌های بیشتری آموزش می‌دهیم. به نظر می‌رسد اینکار تاثیری مثبتی بر دقت تست نداشته و باعث بروز بیش‌برازش می‌شود.\n",
    "باید دقت داشت که به منظور مقایسه عادلانه، قبل از آموزش مدل با تنظیمات متفاوت و جدید باید پارامتر‌های آن را ریست کرد تا بهینه‌سازی را دوباره از وزن‌های تصادفی شروع کنیم، نه وزن‌هایی که قبلا مدل یاد گرفته است.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "52479380ce0947d5989ed7bb8e3eb9f9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/120 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Layer 0: 0.41876474022865295, Layer 1: 0.61633217334747315\r"
     ]
    }
   ],
   "source": [
    "for layer in mlp_model.layers:\n",
    "    layer.reset_parameters()\n",
    "do_train(train_loader_ff, mlp_model, 200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0285a3ae1a0145a58a3448ab78e99abb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/12 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test set: 97.0945%\n"
     ]
    }
   ],
   "source": [
    "do_test(test_loader, mlp_model)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "حال پیچدگی مدل را افزایش می‌دهیم. شاهد افزایش دقت تست هستیم.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "mlp_model2 = FFMultiLayerPerceptron(\n",
    "    hidden_dimensions=[2704, 1024, 1024],\n",
    "    activation=torch.nn.ReLU(),\n",
    "    optimizer=torch.optim.Adam,\n",
    "    layer_optim_learning_rate=0.09,\n",
    "    threshold=9.0,\n",
    "    loss_fn=base_loss,\n",
    ").to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bb61580083ba414d8d25f9a0137c244c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/60 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Layer 0: 0.2733730971813202, Layer 1: 0.371711254119873057\r"
     ]
    }
   ],
   "source": [
    "do_train(train_loader_ff, mlp_model2, 60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8045e332834b40e88f5bbbbbcacc9eda",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/12 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test set: 98.0060%\n"
     ]
    }
   ],
   "source": [
    "do_test(test_loader, mlp_model2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px;\">\n",
    "حال در هر لحظه، یک لایه را آموزش می‌دهیم. این کار به نظر تاثیر مثبتی بر دقت تست دارد و باعث افزایش آن می‌شود، اما دقت آن از مدلی پیچیده‌تر بیشتر نیست.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bc7b8fe1dc51470e8192fbc7b230af57",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/2 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 60/60, Layer 0: 0.28755465149879456\n",
      "\n",
      "Epoch: 60/60, Layer 1: 0.33019915223121643\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for layer in mlp_model.layers:\n",
    "    layer.reset_parameters()\n",
    "mlp_model.train_batch_progressive(60, train_loader_ff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b3c386af425a4a9ca2c775a1e14d466d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/12 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test set: 97.9735%\n"
     ]
    }
   ],
   "source": [
    "do_test(test_loader, mlp_model)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4 style=\"direction:rtl; padding-right:25px\">\n",
    "آموزش و ارزیابی شبکه با پس‌انتشار خطا\n",
    "</h4>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "در این بخش، آموزش را با روش پس‌انتشار خطا یا Backpropagation انجام می‌دهیم. ابتدا توابع کمکی و دیتالودر را تعریف می‌کنیم.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = DataLoader(\n",
    "    train_dataset, batch_size=1024, shuffle=True\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fn = torch.nn.CrossEntropyLoss()\n",
    "n_epochs = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "mlp_backprop_model = MultiLayerPerceptron(\n",
    "    hidden_dimensions=[2704, 512, 512, 10],\n",
    "    activation=torch.nn.ReLU(),\n",
    ").to(device)\n",
    "optimizer = torch.optim.Adam(mlp_backprop_model.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f9fde46cb8da4fef82a84d95025672c6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.00027054629754275084\r"
     ]
    }
   ],
   "source": [
    "for epoch in tqdm(range(n_epochs)):\n",
    "    for i, (X_train, Y_train) in enumerate(train_loader):\n",
    "        X_train = X_train.to(device)\n",
    "        Y_train = Y_train.to(device)\n",
    "\n",
    "        Y_pred = mlp_backprop_model(X_train)\n",
    "\n",
    "        loss = loss_fn(Y_pred, Y_train)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        print(f\"Loss: {loss}\", end=\"\\r\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c20f677021f345cd8b998f5087e16333",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/12 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 98.7141%\n",
      "Test error: 1.2859%\n"
     ]
    }
   ],
   "source": [
    "accuracy = 0\n",
    "counter = 0\n",
    "\n",
    "for X_test, Y_test in tqdm(test_loader, total=len(test_loader)):\n",
    "    X_test = X_test.to(device)\n",
    "    Y_test = Y_test.to(device)\n",
    "    counter += len(X_test)\n",
    "    accuracy += (\n",
    "        torch.softmax(mlp_backprop_model(X_test), 1)\n",
    "        .argmax(1)\n",
    "        .eq(Y_test)\n",
    "        .sum()\n",
    "    )\n",
    "\n",
    "print(f\"Accuracy: {accuracy/counter:.4%}\")\n",
    "print(f\"Test error: {1 - accuracy/counter:.4%}\")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"direction:rtl; padding-right:25px\">\n",
    "همانطور که مشخص است، آموزش مدل با پس‌انتشار خطا، در گام‌های کمتر به خطای بسیار کوچکتری روی داده‌های آموزشی می‌رسد، همچنین دقت تست بیشتری نیز دارد. در نتیجه به نظر بعید است که الگوریتم forward-forward در کارکردهای معمولی جایگزین پس‌انتشار خطا شود.\n",
    "</p>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "570feb405e2e27c949193ac68f46852414290d515b0ba6e5d90d076ed2284471"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}