mnist.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d12a7a08-9ff0-4ca3-b240-a4433958c312",
   "metadata": {},
   "source": [
    "## imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f9cb5650-b5dd-4d3c-a45e-d5c19e8898de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using cuda device for FINDER\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import torch.nn.functional as F\n",
    "import pickle\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "import FINDER_core"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "23a8601b-09ae-45f7-a811-51c8d892e009",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using cuda device\n"
     ]
    }
   ],
   "source": [
    "device = (\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using {device} device\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58634d2c-90b9-45d4-a078-da3d96b6dbdc",
   "metadata": {},
   "source": [
    "## dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "db4859b2-b51f-4c25-b949-64d91782cf0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define transformation for input data\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),  # Convert PIL image to tensor\n",
    "    transforms.Normalize((0.1307,), (0.3081,))  # Normalize the image data\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7a6cb6af-fce9-4cdc-ba66-cd2d68f4c120",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Download MNIST dataset\n",
    "train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n",
    "test_dataset = torchvision.datasets.MNIST(root='./data', train=False, transform=transform, download=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c1e1ded7-3c84-4b9e-8fe2-00d441e8953a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define data loaders\n",
    "batch_size = len(train_dataset)\n",
    "\n",
    "# Define data loaders with full batch size\n",
    "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f557d3ff-b765-40ed-8d65-2999565770b3",
   "metadata": {},
   "source": [
    "## FNN class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "32ca383b-7484-4ffa-b541-a7474cd12a78",
   "metadata": {},
   "outputs": [],
   "source": [
    "class FNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(FNN, self).__init__()\n",
    "        self.fc1 = nn.Linear(28 * 28, 512)\n",
    "        self.fc2 = nn.Linear(512, 256)\n",
    "        self.fc3 = nn.Linear(256, 128)\n",
    "        self.fc4 = nn.Linear(128, 64)\n",
    "        self.fc5 = nn.Linear(64, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.view(-1, 28 * 28)  # Flatten the input image\n",
    "        x = torch.relu(self.fc1(x))\n",
    "        x = torch.relu(self.fc2(x))\n",
    "        x = torch.relu(self.fc3(x))\n",
    "        x = torch.relu(self.fc4(x))\n",
    "        x = self.fc5(x)\n",
    "        return x\n",
    "\n",
    "    def loss_grad(self, param, inputs, labels, no_grad = False):\n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "        '''\n",
    "        zeroeing gradients\n",
    "        '''\n",
    "        torch.nn.utils.vector_to_parameters(param, self.parameters())\n",
    "        self.zero_grad(set_to_none=True)\n",
    "        \n",
    "        '''\n",
    "        loss and grads\n",
    "        '''\n",
    "        outputs = model(inputs)\n",
    "\n",
    "        if no_grad == False:\n",
    "            ls = criterion(outputs, labels)\n",
    "            ls.backward()\n",
    "            grads = torch.cat([param.grad.data.view(-1) for param in self.parameters()], dim=0)\n",
    "            return ls.item(), grads\n",
    "            \n",
    "        else:\n",
    "            with torch.no_grad():\n",
    "                ls = criterion(outputs, labels)\n",
    "                return ls.item()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd456f3e-ff9c-438c-9ab5-f5e227355105",
   "metadata": {},
   "source": [
    "## create model and loss criteria"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a839d7af-e231-4773-b7ff-ab6beafbad95",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = FNN().to(device)\n",
    "start = torch.nn.utils.parameters_to_vector(model.parameters())\n",
    "criterion = nn.CrossEntropyLoss()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a7a29909-8655-4a44-aac5-8b95a37c80aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = FINDER_core.FINDER(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d692931c-47a9-42d0-b3a8-94becb187275",
   "metadata": {},
   "source": [
    "## training loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e52f6943-2858-4a8f-bd79-aa2bd6226a09",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "575050"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3cc28e88-852d-46fc-802a-ace2c3b3d716",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1] loss: 2.273274\n",
      "Epoch [2] loss: 2.211229\n",
      "Epoch [3] loss: 1.807832\n",
      "Epoch [4] loss: 1.602540\n",
      "Epoch [5] loss: 1.410159\n",
      "Epoch [6] loss: 1.397610\n",
      "Epoch [7] loss: 0.844113\n",
      "Epoch [8] loss: 0.836775\n",
      "Epoch [9] loss: 0.820736\n",
      "Epoch [10] loss: 0.749528\n",
      "Epoch [11] loss: 0.735693\n",
      "Epoch [12] loss: 0.708276\n",
      "Epoch [13] loss: 0.630017\n",
      "Epoch [14] loss: 0.622146\n",
      "Epoch [15] loss: 0.589133\n",
      "Epoch [16] loss: 0.572277\n",
      "Epoch [17] loss: 0.554945\n",
      "Epoch [18] loss: 0.548975\n",
      "Epoch [19] loss: 0.542607\n",
      "Epoch [20] loss: 0.472938\n",
      "Epoch [21] loss: 0.464438\n",
      "Epoch [22] loss: 0.455697\n",
      "Epoch [23] loss: 0.437523\n",
      "Epoch [24] loss: 0.421712\n",
      "Epoch [25] loss: 0.411343\n",
      "Epoch [26] loss: 0.386193\n",
      "Epoch [27] loss: 0.377867\n",
      "Epoch [28] loss: 0.370148\n",
      "Epoch [29] loss: 0.348868\n",
      "Epoch [30] loss: 0.337197\n",
      "Epoch [31] loss: 0.320886\n",
      "Epoch [32] loss: 0.311563\n",
      "Epoch [33] loss: 0.302540\n",
      "Epoch [34] loss: 0.280505\n",
      "Epoch [35] loss: 0.274636\n",
      "Epoch [36] loss: 0.253208\n",
      "Epoch [37] loss: 0.249024\n",
      "Epoch [38] loss: 0.243716\n",
      "Epoch [39] loss: 0.227993\n",
      "Epoch [40] loss: 0.209532\n",
      "Epoch [41] loss: 0.200082\n",
      "Epoch [42] loss: 0.199193\n",
      "Epoch [43] loss: 0.181735\n",
      "Epoch [44] loss: 0.174455\n",
      "Epoch [45] loss: 0.167882\n",
      "Epoch [46] loss: 0.154828\n",
      "Epoch [47] loss: 0.145590\n",
      "Epoch [48] loss: 0.143417\n",
      "Epoch [49] loss: 0.138231\n",
      "Epoch [50] loss: 0.129639\n",
      "Epoch [51] loss: 0.122870\n",
      "Epoch [52] loss: 0.117029\n",
      "Epoch [53] loss: 0.109905\n",
      "Epoch [54] loss: 0.102506\n",
      "Epoch [55] loss: 0.097721\n",
      "Epoch [56] loss: 0.092905\n",
      "Epoch [57] loss: 0.085398\n",
      "Epoch [58] loss: 0.082409\n",
      "Epoch [59] loss: 0.077070\n",
      "Epoch [60] loss: 0.073611\n",
      "Epoch [61] loss: 0.068672\n",
      "Epoch [62] loss: 0.065561\n",
      "Epoch [63] loss: 0.062943\n",
      "Epoch [64] loss: 0.057714\n",
      "Epoch [65] loss: 0.055228\n",
      "Epoch [66] loss: 0.051005\n",
      "Epoch [67] loss: 0.048874\n",
      "Epoch [68] loss: 0.047034\n",
      "Epoch [69] loss: 0.045151\n",
      "Epoch [70] loss: 0.040056\n",
      "Epoch [71] loss: 0.039861\n",
      "Epoch [72] loss: 0.038862\n",
      "Epoch [73] loss: 0.036065\n",
      "Epoch [74] loss: 0.034730\n",
      "Epoch [75] loss: 0.032900\n",
      "Epoch [76] loss: 0.030710\n",
      "Epoch [77] loss: 0.028582\n",
      "Epoch [78] loss: 0.027095\n",
      "Epoch [79] loss: 0.025984\n",
      "Epoch [80] loss: 0.023792\n",
      "Epoch [81] loss: 0.021848\n",
      "Epoch [82] loss: 0.020736\n",
      "Epoch [83] loss: 0.019995\n",
      "Epoch [84] loss: 0.017690\n",
      "Epoch [85] loss: 0.017635\n",
      "Epoch [86] loss: 0.016516\n",
      "Epoch [87] loss: 0.016347\n",
      "Epoch [88] loss: 0.014652\n",
      "Epoch [89] loss: 0.013819\n",
      "Epoch [90] loss: 0.012489\n",
      "Epoch [91] loss: 0.011767\n",
      "Epoch [92] loss: 0.011344\n",
      "Epoch [93] loss: 0.009852\n",
      "Epoch [94] loss: 0.009597\n",
      "Epoch [95] loss: 0.008950\n",
      "Epoch [96] loss: 0.008121\n",
      "Epoch [97] loss: 0.008058\n",
      "Epoch [98] loss: 0.006983\n",
      "Epoch [99] loss: 0.006711\n",
      "Epoch [100] loss: 0.006517\n",
      "finished training in 847.7190940380096 seconds\n"
     ]
    }
   ],
   "source": [
    "tic = time.time()\n",
    "fX_mnist_FINDER = []\n",
    "for epoch in range(100):  # loop over the dataset multiple times\n",
    "    model.train()\n",
    "    running_loss = 0.0\n",
    "    total = 0.0    \n",
    "    for i, data in enumerate(train_loader, 0):\n",
    "        inputs, labels = data\n",
    "        min_fitness = optimizer.step(inputs, labels)\n",
    "\n",
    "        running_loss += min_fitness * inputs.size(0)\n",
    "    running_loss /= len(train_dataset)\n",
    "    fX_mnist_FINDER.append(running_loss)\n",
    "    print('Epoch [%d] loss: %.6f' %\n",
    "          (epoch + 1, running_loss))\n",
    "toc = time.time()\n",
    "print(\"finished training in\", toc - tic, \"seconds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b72086d8-8c60-4780-9349-d0e1e3498856",
   "metadata": {},
   "source": [
    "## testing accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0af276c6-bf1e-4a76-86b7-0f1894f9fbbe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test set: 97.91 %\n"
     ]
    }
   ],
   "source": [
    "model.eval()  # Set the model to evaluation mode\n",
    "correct = 0\n",
    "total = 0\n",
    "with torch.no_grad():\n",
    "    for inputs, labels in test_loader:\n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "        outputs = model(inputs)\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "print(f\"Accuracy on test set: {correct / total * 100} %\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "342a5fc0-09bf-4a2b-bd2b-bbd417f9b0c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on train set: 99.89833333333334 %\n"
     ]
    }
   ],
   "source": [
    "model.eval()  # Set the model to evaluation mode\n",
    "correct = 0\n",
    "total = 0\n",
    "with torch.no_grad():\n",
    "    for inputs, labels in train_loader:\n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "        outputs = model(inputs)\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "print(f\"Accuracy on train set: {correct / total * 100} %\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "12db701c-d52a-4467-85a3-4cad3f51946f",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(fX_mnist_FINDER, 'mnist_optim_fx_N575050_fullbatch.pt')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8227264-8f75-4700-a524-30b860a851f8",
   "metadata": {},
   "source": [
    "# adam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7f0d0c60-d0df-473d-b6a1-b32d5022bebe",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1] loss: 2.309211\n",
      "Epoch [2] loss: 2.283740\n",
      "Epoch [3] loss: 2.250462\n",
      "Epoch [4] loss: 2.198483\n",
      "Epoch [5] loss: 2.119750\n",
      "Epoch [6] loss: 2.009960\n",
      "Epoch [7] loss: 1.871532\n",
      "Epoch [8] loss: 1.711447\n",
      "Epoch [9] loss: 1.531711\n",
      "Epoch [10] loss: 1.341251\n",
      "Epoch [11] loss: 1.151588\n",
      "Epoch [12] loss: 0.978668\n",
      "Epoch [13] loss: 0.854525\n",
      "Epoch [14] loss: 0.839317\n",
      "Epoch [15] loss: 0.779157\n",
      "Epoch [16] loss: 0.707325\n",
      "Epoch [17] loss: 0.650895\n",
      "Epoch [18] loss: 0.629215\n",
      "Epoch [19] loss: 0.573686\n",
      "Epoch [20] loss: 0.581501\n",
      "Epoch [21] loss: 0.531450\n",
      "Epoch [22] loss: 0.520111\n",
      "Epoch [23] loss: 0.503338\n",
      "Epoch [24] loss: 0.481905\n",
      "Epoch [25] loss: 0.469859\n",
      "Epoch [26] loss: 0.455392\n",
      "Epoch [27] loss: 0.445272\n",
      "Epoch [28] loss: 0.423514\n",
      "Epoch [29] loss: 0.421549\n",
      "Epoch [30] loss: 0.411802\n",
      "Epoch [31] loss: 0.391042\n",
      "Epoch [32] loss: 0.388431\n",
      "Epoch [33] loss: 0.383061\n",
      "Epoch [34] loss: 0.367062\n",
      "Epoch [35] loss: 0.362396\n",
      "Epoch [36] loss: 0.356672\n",
      "Epoch [37] loss: 0.346328\n",
      "Epoch [38] loss: 0.342031\n",
      "Epoch [39] loss: 0.335845\n",
      "Epoch [40] loss: 0.327412\n",
      "Epoch [41] loss: 0.323001\n",
      "Epoch [42] loss: 0.317605\n",
      "Epoch [43] loss: 0.310845\n",
      "Epoch [44] loss: 0.305501\n",
      "Epoch [45] loss: 0.300986\n",
      "Epoch [46] loss: 0.295644\n",
      "Epoch [47] loss: 0.290269\n",
      "Epoch [48] loss: 0.285926\n",
      "Epoch [49] loss: 0.281826\n",
      "Epoch [50] loss: 0.276749\n",
      "Epoch [51] loss: 0.272681\n",
      "Epoch [52] loss: 0.269020\n",
      "Epoch [53] loss: 0.264434\n",
      "Epoch [54] loss: 0.260753\n",
      "Epoch [55] loss: 0.257266\n",
      "Epoch [56] loss: 0.253102\n",
      "Epoch [57] loss: 0.249734\n",
      "Epoch [58] loss: 0.246420\n",
      "Epoch [59] loss: 0.242642\n",
      "Epoch [60] loss: 0.239265\n",
      "Epoch [61] loss: 0.236205\n",
      "Epoch [62] loss: 0.232850\n",
      "Epoch [63] loss: 0.229349\n",
      "Epoch [64] loss: 0.226430\n",
      "Epoch [65] loss: 0.223435\n",
      "Epoch [66] loss: 0.220073\n",
      "Epoch [67] loss: 0.217170\n",
      "Epoch [68] loss: 0.214305\n",
      "Epoch [69] loss: 0.211274\n",
      "Epoch [70] loss: 0.208410\n",
      "Epoch [71] loss: 0.205610\n",
      "Epoch [72] loss: 0.202820\n",
      "Epoch [73] loss: 0.200059\n",
      "Epoch [74] loss: 0.197422\n",
      "Epoch [75] loss: 0.194730\n",
      "Epoch [76] loss: 0.192154\n",
      "Epoch [77] loss: 0.189642\n",
      "Epoch [78] loss: 0.187085\n",
      "Epoch [79] loss: 0.184649\n",
      "Epoch [80] loss: 0.182240\n",
      "Epoch [81] loss: 0.179841\n",
      "Epoch [82] loss: 0.177491\n",
      "Epoch [83] loss: 0.175215\n",
      "Epoch [84] loss: 0.172914\n",
      "Epoch [85] loss: 0.170689\n",
      "Epoch [86] loss: 0.168490\n",
      "Epoch [87] loss: 0.166304\n",
      "Epoch [88] loss: 0.164177\n",
      "Epoch [89] loss: 0.162065\n",
      "Epoch [90] loss: 0.159968\n",
      "Epoch [91] loss: 0.157925\n",
      "Epoch [92] loss: 0.155900\n",
      "Epoch [93] loss: 0.153895\n",
      "Epoch [94] loss: 0.151938\n",
      "Epoch [95] loss: 0.149995\n",
      "Epoch [96] loss: 0.148078\n",
      "Epoch [97] loss: 0.146190\n",
      "Epoch [98] loss: 0.144314\n",
      "Epoch [99] loss: 0.142455\n",
      "Epoch [100] loss: 0.140632\n",
      "\n",
      "finished training with Adam in  708.4186515808105  seconds\n",
      "\n",
      "Accuracy on test set: 95.6\n",
      "Accuracy on train set: 95.94\n"
     ]
    }
   ],
   "source": [
    "class FNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(FNN, self).__init__()\n",
    "        self.fc1 = nn.Linear(28 * 28, 512)\n",
    "        self.fc2 = nn.Linear(512, 256)\n",
    "        self.fc3 = nn.Linear(256, 128)\n",
    "        self.fc4 = nn.Linear(128, 64)\n",
    "        self.fc5 = nn.Linear(64, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.view(-1, 28 * 28)  # Flatten the input image\n",
    "        x = torch.relu(self.fc1(x))\n",
    "        x = torch.relu(self.fc2(x))\n",
    "        x = torch.relu(self.fc3(x))\n",
    "        x = torch.relu(self.fc4(x))\n",
    "        x = self.fc5(x)\n",
    "        return x\n",
    "\n",
    "# Initialize the model, loss function, and optimizer\n",
    "model_adam = FNN().to(device)\n",
    "torch.nn.utils.vector_to_parameters(start, model_adam.parameters()) #to set same starting point for Adam\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(model_adam.parameters(), lr=0.001)\n",
    "fX_adam_mnist = []\n",
    "# Train the model\n",
    "num_epochs = 100\n",
    "tic = time.time()\n",
    "for epoch in range(num_epochs):\n",
    "    model_adam.train()  # Set the model to train mode\n",
    "    running_loss = 0.0\n",
    "    for i, (inputs, labels) in enumerate(train_loader):\n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "        optimizer.zero_grad()  # Zero the parameter gradients\n",
    "        outputs = model_adam(inputs)  # Forward pass\n",
    "        loss = criterion(outputs, labels)  # Compute the loss\n",
    "        loss.backward()  # Backward pass\n",
    "        optimizer.step()  # Optimize\n",
    "        running_loss += loss.item() * inputs.size(0)\n",
    "    print('Epoch [%d] loss: %.6f' %\n",
    "      (epoch + 1, running_loss/len(train_dataset)))\n",
    "\n",
    "    fX_adam_mnist.append(running_loss/ len(train_dataset))\n",
    "toc = time.time()\n",
    "print(\"\\nfinished training with Adam in \",toc-tic,\" seconds\\n\")\n",
    "# Test the model\n",
    "model_adam.eval()  # Set the model to evaluation mode\n",
    "correct = 0\n",
    "total = 0\n",
    "with torch.no_grad():\n",
    "    for inputs, labels in test_loader:\n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "        outputs = model_adam(inputs)\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "print(f\"Accuracy on test set: {correct / total * 100}\")\n",
    "\n",
    "model_adam.eval()  # Set the model to evaluation mode\n",
    "correct = 0\n",
    "total = 0\n",
    "with torch.no_grad():\n",
    "    for inputs, labels in train_loader:\n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "        outputs = model_adam(inputs)\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "print(f\"Accuracy on train set: {correct / total*100}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "69318eba-ca1f-4462-957f-f76996b309e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(fX_adam_mnist, 'mnist_adam_fx_N575050_fullbatch.pt')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce074052-a4f9-43d3-84ef-81956ebc72ad",
   "metadata": {},
   "source": [
    "# plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "8afe6672-bfd5-4f75-8738-bf74fa249e43",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(fX_mnist_FINDER,'r', label = 'FINDER')\n",
    "plt.plot(fX_adam_mnist,'b', label='Adam')\n",
    "plt.xlabel('number of epochs')\n",
    "plt.ylabel('log(f(x))')\n",
    "plt.yscale('log')\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f8125fc-4bb1-4d20-8bfc-3b90a1a73da9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}