HW1_BlaiseIradukunda.linear.ipynb

hw1_blaiseiradukunda-linear.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "HW1_BlaiseIradukunda.linear.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMGReF8JLXsDdyoSEOWLs6z",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/Blezzoh/25c441d0ffeed3ae0a9ce6c3e2271469/hw1_blaiseiradukunda-linear.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# code for displaying data and labels sample\n",
        "\n",
        "# example = 0\n",
        "# image, label = trainset[example]\n",
        "# print(\"this is an image of a \", classes[label])\n",
        "# print(\"size is \", str(image.shape))\n",
        "# plt.imshow(image[0,0:32, 0:32], cmap='Reds')\n",
        "# # plt.imshow(image[1,0:32, 0:32], cmap='Greens')\n",
        "# # plt.imshow(image[2,0:32, 0:32], cmap='Blues')"
      ],
      "metadata": {
        "id": "_iu3uozmucOG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8-q1PVPDpLgY",
        "cellView": "code"
      },
      "outputs": [],
      "source": [
        "#@title Default title text\n",
        "%matplotlib inline\n",
        "import torchvision\n",
        "# will use this to for transformation to tensor aka matrices\n",
        "import torchvision.transforms as transforms\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "# batches and dataloaders\n",
        "from torch.utils.data.sampler import SubsetRandomSampler\n",
        "from torch.utils.data.dataloader import DataLoader\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as f\n",
        "\n",
        "\n",
        "#train set 50,000\n",
        "data_set = torchvision.datasets.CIFAR10(root='./data', train=True,\n",
        "                                        download=True, transform=transforms.ToTensor())\n",
        "\n",
        "#test set 10,000\n",
        "testset = torchvision.datasets.CIFAR10(root='./data', train=False,\n",
        "                                       download=True,transform=transforms.ToTensor())\n",
        "classes = ('plane', 'car', 'bird', 'cat',\n",
        "           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n",
        "\n",
        "\n",
        "\n",
        "# data set total, cross validation percentatage=test data percentage of total, batch size\n",
        "total = 50000\n",
        "cross_v_perc = 0.2\n",
        "batch_size = 100\n",
        "\n",
        "\n",
        "#function to randomly sample training and cross validation sets\n",
        "def splitIndeces(total ,cross_v_perc):\n",
        "  cross_v_total = int(total * cross_v_perc)\n",
        "  training_total = total - cross_v_total\n",
        "  indices = np.random.permutation(total)\n",
        "  return indices[cross_v_total:], indices[:cross_v_total]\n",
        "\n",
        "training_indeces, cross_v_indices = splitIndeces(total,cross_v_perc)\n",
        "\n",
        "training_sampler = SubsetRandomSampler(training_indeces)\n",
        "training_loader = DataLoader(dataset=data_set, batch_size=batch_size, sampler=training_sampler)\n",
        "\n",
        "cross_v_sampler = SubsetRandomSampler(cross_v_indices)\n",
        "cross_v_loader = DataLoader(dataset=data_set, batch_size=batch_size, sampler=cross_v_sampler)\n",
        "\n",
        "# rows of weights\n",
        "weight_rows = 3*32*32\n",
        "weight_cols = 10\n",
        "\n",
        "\n",
        "\n",
        "class Model(nn.Module):\n",
        "  def __init__(self, bias=True):\n",
        "    super().__init__()\n",
        "    self.linear = nn.Linear(weight_rows,weight_cols, bias=bias)\n",
        "  def forward(self, xb):\n",
        "    xb = xb.reshape(-1, 3072)\n",
        "    out = self.linear(xb)\n",
        "    return out\n",
        "\n",
        "def custom_accuracy(outputs, labels):\n",
        "  a , predictions = torch.max(outputs, dim=1)\n",
        "  return torch.sum(labels==predictions).item()/len(labels)\n",
        "\n",
        "entropy_loss = f.cross_entropy\n",
        "\n",
        "# loss function for a batch\n",
        "def loss_fn_batch(model, loss_fn, xb, yb, optimizer=None, metric=None):\n",
        "  # calculating loss\n",
        "  d_predictions = model(xb)\n",
        "  d_loss = loss_fn(d_predictions, yb)\n",
        "  \n",
        "  if optimizer is not None:\n",
        "    # gradient descent\n",
        "    d_loss.backward()\n",
        "    #update parameters\n",
        "    optimizer.step()\n",
        "    # reset gradient to 0\n",
        "    optimizer.zero_grad()\n",
        "  \n",
        "  metric_result = None\n",
        "  if metric is not None:\n",
        "    metric_result = metric(d_predictions, yb)\n",
        "  return d_loss.item(), len(xb), metric_result\n",
        "\n",
        "def evaluate_avg(model, loss_fn, valid_dl, metric=None): \n",
        "  with torch.no_grad():\n",
        "    results = [loss_fn_batch(model, loss_fn, xb, yb, metric=metric) for xb,yb in valid_dl]\n",
        "    # separate losses, counts, and metrics\n",
        "    losses, nums, metrics = zip(*results)\n",
        "    total = np.sum(nums)\n",
        "    avg_loss = np.sum(np.multiply(losses, nums))/total\n",
        "\n",
        "    if metric is not None:\n",
        "      avg_metric = np.sum(np.multiply(metrics, nums))/total\n",
        "  return avg_loss, total, avg_metric\n",
        "\n",
        "\n",
        "def fit_model(epochs, model, loss_fn, optimizer, training_set, validation_set, metric=None):\n",
        "  # will update with new cross validation accuracy, 0.10 is a placeholder for untrained\n",
        "  val_list = [0.10]\n",
        "\n",
        "  for epoch in range(epochs):\n",
        "    #one set gradient descent each batch\n",
        "    for xb, yb in training_set:\n",
        "      loss, _, loss_metric = loss_fn_batch(model, loss_fn, xb, yb, optimizer)\n",
        "    val_result = evaluate_avg(model, loss_fn, validation_set, metric)\n",
        "    val_loss, _, val_metric = val_result\n",
        "    val_list.append(val_metric)\n",
        "\n",
        "    if metric is None:\n",
        "      print('epoch [{}/{}], loss: {:.4f}'.format(epoch+1,epochs, val_loss))\n",
        "    else:\n",
        "      print('epoch [{}/{}], loss: {:.4f}, {}: {:.4f}'.format(epoch+1,epochs, val_loss, metric.__name__, val_metric))\n",
        "  return val_list\n",
        "\n",
        "\n",
        "# for images, labels in training_loader:\n",
        "#   outputs = model(images)\n",
        "\n",
        "# print('output.shape:',outputs[0])\n",
        "\n",
        "# prob_softmax = f.softmax(outputs, dim=1)\n",
        "\n",
        "# print('converted into probabilities(0,1) using softmax', prob_softmax[0].data, labels[0])\n",
        "\n",
        "# maxProb, predictions = torch.max(prob_softmax, dim=1)\n",
        "\n",
        "# print(predictions, labels==predictions, custom_accuracy(labels, predictions))\n",
        "\n",
        "# cross_ent = entropy_loss(outputs, labels)\n",
        "\n",
        "# print(cross_ent.to)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Logistic regression seemed like the way to go since it is a classification problems with 10 classes. This model uses softmax to adjust outputs between 0 and 1. It uses cross entropy loss function, loads data by batches of 100, and updates parameters using mini batching gradient descent.\n",
        "\n",
        "Our dataset is made of 40,000 training set and 10,000 cross validation set.  \n"
      ],
      "metadata": {
        "id": "JSguqgY449rW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = Model()\n",
        "learning_rate = 0.009\n",
        "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
        "train_list = fit_model(100, model, entropy_loss, optimizer, training_loader, cross_v_loader, metric=custom_accuracy)\n",
        "plt.plot(train_list, '-x')\n",
        "axes = plt.gca() # get current axes\n",
        "axes.set_ylim([0,1])\n",
        "plt.xlabel('epoch')\n",
        "plt.ylabel('accuracy')\n",
        "plt.title('accuracy vs # epoch: learning rate 0.009, with bias')\n"
      ],
      "metadata": {
        "id": "EdzR519AI2uF",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        },
        "outputId": "a71f4a31-9a38-4fe0-e5e4-3df9c165b313"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'accuracy vs # epoch: learning rate 0.009, with bias')"
            ]
          },
          "metadata": {},
          "execution_count": 4
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "esofi1yH_roi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = Model(True)\n",
        "learning_rate = 0.001\n",
        "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
        "train_list = fit_model(100, model, entropy_loss, optimizer, training_loader, cross_v_loader, metric=custom_accuracy)\n",
        "plt.plot(train_list, '-x')\n",
        "axes = plt.gca() # get current axes\n",
        "axes.set_ylim([0,1])\n",
        "plt.xlabel('epoch')\n",
        "plt.ylabel('accuracy')\n",
        "plt.title('accuracy vs # epoch: learning rate 0.001, with bias')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "lZRAtt6U61fY",
        "outputId": "e44e2d4b-e245-4d12-beed-5f11e7e113e1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "epoch [1/100], loss: 2.1182, custom_accuracy: 0.2654\n",
            "epoch [2/100], loss: 2.0426, custom_accuracy: 0.2962\n",
            "epoch [3/100], loss: 1.9985, custom_accuracy: 0.3168\n",
            "epoch [4/100], loss: 1.9677, custom_accuracy: 0.3263\n",
            "epoch [5/100], loss: 1.9452, custom_accuracy: 0.3309\n",
            "epoch [6/100], loss: 1.9300, custom_accuracy: 0.3464\n",
            "epoch [7/100], loss: 1.9142, custom_accuracy: 0.3469\n",
            "epoch [8/100], loss: 1.9034, custom_accuracy: 0.3489\n",
            "epoch [9/100], loss: 1.8923, custom_accuracy: 0.3552\n",
            "epoch [10/100], loss: 1.8868, custom_accuracy: 0.3531\n",
            "epoch [11/100], loss: 1.8778, custom_accuracy: 0.3563\n",
            "epoch [12/100], loss: 1.8698, custom_accuracy: 0.3575\n",
            "epoch [13/100], loss: 1.8651, custom_accuracy: 0.3580\n",
            "epoch [14/100], loss: 1.8601, custom_accuracy: 0.3605\n",
            "epoch [15/100], loss: 1.8568, custom_accuracy: 0.3599\n",
            "epoch [16/100], loss: 1.8512, custom_accuracy: 0.3637\n",
            "epoch [17/100], loss: 1.8493, custom_accuracy: 0.3655\n",
            "epoch [18/100], loss: 1.8444, custom_accuracy: 0.3599\n",
            "epoch [19/100], loss: 1.8394, custom_accuracy: 0.3684\n",
            "epoch [20/100], loss: 1.8365, custom_accuracy: 0.3665\n",
            "epoch [21/100], loss: 1.8326, custom_accuracy: 0.3706\n",
            "epoch [22/100], loss: 1.8307, custom_accuracy: 0.3716\n",
            "epoch [23/100], loss: 1.8296, custom_accuracy: 0.3708\n",
            "epoch [24/100], loss: 1.8256, custom_accuracy: 0.3727\n",
            "epoch [25/100], loss: 1.8248, custom_accuracy: 0.3734\n",
            "epoch [26/100], loss: 1.8247, custom_accuracy: 0.3718\n",
            "epoch [27/100], loss: 1.8198, custom_accuracy: 0.3741\n",
            "epoch [28/100], loss: 1.8191, custom_accuracy: 0.3748\n",
            "epoch [29/100], loss: 1.8178, custom_accuracy: 0.3733\n",
            "epoch [30/100], loss: 1.8158, custom_accuracy: 0.3733\n",
            "epoch [31/100], loss: 1.8144, custom_accuracy: 0.3742\n",
            "epoch [32/100], loss: 1.8117, custom_accuracy: 0.3761\n",
            "epoch [33/100], loss: 1.8104, custom_accuracy: 0.3776\n",
            "epoch [34/100], loss: 1.8090, custom_accuracy: 0.3768\n",
            "epoch [35/100], loss: 1.8079, custom_accuracy: 0.3766\n",
            "epoch [36/100], loss: 1.8045, custom_accuracy: 0.3771\n",
            "epoch [37/100], loss: 1.8033, custom_accuracy: 0.3801\n",
            "epoch [38/100], loss: 1.8031, custom_accuracy: 0.3766\n",
            "epoch [39/100], loss: 1.8013, custom_accuracy: 0.3795\n",
            "epoch [40/100], loss: 1.8003, custom_accuracy: 0.3765\n",
            "epoch [41/100], loss: 1.8004, custom_accuracy: 0.3802\n",
            "epoch [42/100], loss: 1.7991, custom_accuracy: 0.3779\n",
            "epoch [43/100], loss: 1.7966, custom_accuracy: 0.3819\n",
            "epoch [44/100], loss: 1.7974, custom_accuracy: 0.3836\n",
            "epoch [45/100], loss: 1.7949, custom_accuracy: 0.3824\n",
            "epoch [46/100], loss: 1.7926, custom_accuracy: 0.3854\n",
            "epoch [47/100], loss: 1.7938, custom_accuracy: 0.3795\n",
            "epoch [48/100], loss: 1.7934, custom_accuracy: 0.3828\n",
            "epoch [49/100], loss: 1.7898, custom_accuracy: 0.3877\n",
            "epoch [50/100], loss: 1.7906, custom_accuracy: 0.3830\n",
            "epoch [51/100], loss: 1.7887, custom_accuracy: 0.3842\n",
            "epoch [52/100], loss: 1.7880, custom_accuracy: 0.3829\n",
            "epoch [53/100], loss: 1.7870, custom_accuracy: 0.3835\n",
            "epoch [54/100], loss: 1.7876, custom_accuracy: 0.3846\n",
            "epoch [55/100], loss: 1.7858, custom_accuracy: 0.3884\n",
            "epoch [56/100], loss: 1.7850, custom_accuracy: 0.3858\n",
            "epoch [57/100], loss: 1.7855, custom_accuracy: 0.3858\n",
            "epoch [58/100], loss: 1.7837, custom_accuracy: 0.3862\n",
            "epoch [59/100], loss: 1.7827, custom_accuracy: 0.3870\n",
            "epoch [60/100], loss: 1.7831, custom_accuracy: 0.3876\n",
            "epoch [61/100], loss: 1.7809, custom_accuracy: 0.3886\n",
            "epoch [62/100], loss: 1.7814, custom_accuracy: 0.3907\n",
            "epoch [63/100], loss: 1.7813, custom_accuracy: 0.3878\n",
            "epoch [64/100], loss: 1.7799, custom_accuracy: 0.3890\n",
            "epoch [65/100], loss: 1.7788, custom_accuracy: 0.3875\n",
            "epoch [66/100], loss: 1.7798, custom_accuracy: 0.3885\n",
            "epoch [67/100], loss: 1.7779, custom_accuracy: 0.3907\n",
            "epoch [68/100], loss: 1.7771, custom_accuracy: 0.3886\n",
            "epoch [69/100], loss: 1.7788, custom_accuracy: 0.3871\n",
            "epoch [70/100], loss: 1.7762, custom_accuracy: 0.3867\n",
            "epoch [71/100], loss: 1.7784, custom_accuracy: 0.3900\n",
            "epoch [72/100], loss: 1.7752, custom_accuracy: 0.3896\n",
            "epoch [73/100], loss: 1.7749, custom_accuracy: 0.3892\n",
            "epoch [74/100], loss: 1.7741, custom_accuracy: 0.3892\n",
            "epoch [75/100], loss: 1.7737, custom_accuracy: 0.3908\n",
            "epoch [76/100], loss: 1.7738, custom_accuracy: 0.3911\n",
            "epoch [77/100], loss: 1.7735, custom_accuracy: 0.3911\n",
            "epoch [78/100], loss: 1.7737, custom_accuracy: 0.3900\n",
            "epoch [79/100], loss: 1.7715, custom_accuracy: 0.3904\n",
            "epoch [80/100], loss: 1.7711, custom_accuracy: 0.3906\n",
            "epoch [81/100], loss: 1.7720, custom_accuracy: 0.3924\n",
            "epoch [82/100], loss: 1.7723, custom_accuracy: 0.3904\n",
            "epoch [83/100], loss: 1.7722, custom_accuracy: 0.3909\n",
            "epoch [84/100], loss: 1.7710, custom_accuracy: 0.3905\n",
            "epoch [85/100], loss: 1.7697, custom_accuracy: 0.3949\n",
            "epoch [86/100], loss: 1.7687, custom_accuracy: 0.3913\n",
            "epoch [87/100], loss: 1.7689, custom_accuracy: 0.3911\n",
            "epoch [88/100], loss: 1.7690, custom_accuracy: 0.3911\n",
            "epoch [89/100], loss: 1.7676, custom_accuracy: 0.3951\n",
            "epoch [90/100], loss: 1.7687, custom_accuracy: 0.3941\n",
            "epoch [91/100], loss: 1.7677, custom_accuracy: 0.3945\n",
            "epoch [92/100], loss: 1.7678, custom_accuracy: 0.3921\n",
            "epoch [93/100], loss: 1.7661, custom_accuracy: 0.3917\n",
            "epoch [94/100], loss: 1.7666, custom_accuracy: 0.3967\n",
            "epoch [95/100], loss: 1.7675, custom_accuracy: 0.3915\n",
            "epoch [96/100], loss: 1.7644, custom_accuracy: 0.3940\n",
            "epoch [97/100], loss: 1.7662, custom_accuracy: 0.3914\n",
            "epoch [98/100], loss: 1.7658, custom_accuracy: 0.3915\n",
            "epoch [99/100], loss: 1.7635, custom_accuracy: 0.3967\n",
            "epoch [100/100], loss: 1.7640, custom_accuracy: 0.3959\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'accuracy vs # epoch: learning rate 0.001, with bias')"
            ]
          },
          "metadata": {},
          "execution_count": 6
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "R2BBxPzN_3pw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "I32SG_j0_-lS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = Model(False)\n",
        "learning_rate = 0.009\n",
        "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
        "train_list = fit_model(100, model, entropy_loss, optimizer, training_loader, cross_v_loader, metric=custom_accuracy)\n",
        "plt.plot(train_list, '-x')\n",
        "axes = plt.gca() # get current axes\n",
        "axes.set_ylim([0,1])\n",
        "plt.xlabel('epoch')\n",
        "plt.ylabel('accuracy')\n",
        "plt.title('accuracy vs # epoch: learning rate 0.009, with no bias')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        },
        "id": "YvYocEFv659y",
        "outputId": "39daf8e7-560c-4530-a5f4-f21c55970b16"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'accuracy vs # epoch: learning rate 0.009, with no bias')"
            ]
          },
          "metadata": {},
          "execution_count": 8
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "Pf0u_D6mAk73"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = Model(False)\n",
        "learning_rate = 0.0001\n",
        "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
        "train_list = fit_model(100, model, entropy_loss, optimizer, training_loader, cross_v_loader, metric=custom_accuracy)\n",
        "plt.plot(train_list, '-x')\n",
        "axes = plt.gca() # get current axes\n",
        "axes.set_ylim([0,1])\n",
        "plt.xlabel('epoch')\n",
        "plt.ylabel('accuracy')\n",
        "plt.title('accuracy vs # epoch: learning rate 0.0001, with no bias')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "2VKi7GeoFqCA",
        "outputId": "71bfc9af-56fd-4086-cb96-40fdc75ab900"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "epoch [1/100], loss: 2.2802, custom_accuracy: 0.1343\n",
            "epoch [2/100], loss: 2.2534, custom_accuracy: 0.1593\n",
            "epoch [3/100], loss: 2.2301, custom_accuracy: 0.1873\n",
            "epoch [4/100], loss: 2.2091, custom_accuracy: 0.2086\n",
            "epoch [5/100], loss: 2.1910, custom_accuracy: 0.2155\n",
            "epoch [6/100], loss: 2.1742, custom_accuracy: 0.2325\n",
            "epoch [7/100], loss: 2.1597, custom_accuracy: 0.2388\n",
            "epoch [8/100], loss: 2.1464, custom_accuracy: 0.2444\n",
            "epoch [9/100], loss: 2.1342, custom_accuracy: 0.2543\n",
            "epoch [10/100], loss: 2.1229, custom_accuracy: 0.2597\n",
            "epoch [11/100], loss: 2.1129, custom_accuracy: 0.2614\n",
            "epoch [12/100], loss: 2.1029, custom_accuracy: 0.2695\n",
            "epoch [13/100], loss: 2.0941, custom_accuracy: 0.2740\n",
            "epoch [14/100], loss: 2.0861, custom_accuracy: 0.2742\n",
            "epoch [15/100], loss: 2.0783, custom_accuracy: 0.2783\n",
            "epoch [16/100], loss: 2.0719, custom_accuracy: 0.2847\n",
            "epoch [17/100], loss: 2.0645, custom_accuracy: 0.2867\n",
            "epoch [18/100], loss: 2.0581, custom_accuracy: 0.2914\n",
            "epoch [19/100], loss: 2.0521, custom_accuracy: 0.2926\n",
            "epoch [20/100], loss: 2.0464, custom_accuracy: 0.2948\n",
            "epoch [21/100], loss: 2.0411, custom_accuracy: 0.2969\n",
            "epoch [22/100], loss: 2.0358, custom_accuracy: 0.2977\n",
            "epoch [23/100], loss: 2.0313, custom_accuracy: 0.3009\n",
            "epoch [24/100], loss: 2.0261, custom_accuracy: 0.3027\n",
            "epoch [25/100], loss: 2.0217, custom_accuracy: 0.3063\n",
            "epoch [26/100], loss: 2.0178, custom_accuracy: 0.3068\n",
            "epoch [27/100], loss: 2.0135, custom_accuracy: 0.3067\n",
            "epoch [28/100], loss: 2.0097, custom_accuracy: 0.3095\n",
            "epoch [29/100], loss: 2.0059, custom_accuracy: 0.3115\n",
            "epoch [30/100], loss: 2.0026, custom_accuracy: 0.3133\n",
            "epoch [31/100], loss: 1.9990, custom_accuracy: 0.3167\n",
            "epoch [32/100], loss: 1.9956, custom_accuracy: 0.3154\n",
            "epoch [33/100], loss: 1.9921, custom_accuracy: 0.3177\n",
            "epoch [34/100], loss: 1.9890, custom_accuracy: 0.3177\n",
            "epoch [35/100], loss: 1.9860, custom_accuracy: 0.3190\n",
            "epoch [36/100], loss: 1.9830, custom_accuracy: 0.3219\n",
            "epoch [37/100], loss: 1.9801, custom_accuracy: 0.3222\n",
            "epoch [38/100], loss: 1.9778, custom_accuracy: 0.3217\n",
            "epoch [39/100], loss: 1.9747, custom_accuracy: 0.3229\n",
            "epoch [40/100], loss: 1.9723, custom_accuracy: 0.3244\n",
            "epoch [41/100], loss: 1.9697, custom_accuracy: 0.3233\n",
            "epoch [42/100], loss: 1.9675, custom_accuracy: 0.3274\n",
            "epoch [43/100], loss: 1.9649, custom_accuracy: 0.3261\n",
            "epoch [44/100], loss: 1.9624, custom_accuracy: 0.3270\n",
            "epoch [45/100], loss: 1.9607, custom_accuracy: 0.3298\n",
            "epoch [46/100], loss: 1.9582, custom_accuracy: 0.3297\n",
            "epoch [47/100], loss: 1.9561, custom_accuracy: 0.3309\n",
            "epoch [48/100], loss: 1.9539, custom_accuracy: 0.3307\n",
            "epoch [49/100], loss: 1.9518, custom_accuracy: 0.3324\n",
            "epoch [50/100], loss: 1.9500, custom_accuracy: 0.3333\n",
            "epoch [51/100], loss: 1.9481, custom_accuracy: 0.3327\n",
            "epoch [52/100], loss: 1.9462, custom_accuracy: 0.3341\n",
            "epoch [53/100], loss: 1.9447, custom_accuracy: 0.3345\n",
            "epoch [54/100], loss: 1.9426, custom_accuracy: 0.3353\n",
            "epoch [55/100], loss: 1.9409, custom_accuracy: 0.3353\n",
            "epoch [56/100], loss: 1.9391, custom_accuracy: 0.3366\n",
            "epoch [57/100], loss: 1.9373, custom_accuracy: 0.3373\n",
            "epoch [58/100], loss: 1.9357, custom_accuracy: 0.3376\n",
            "epoch [59/100], loss: 1.9344, custom_accuracy: 0.3373\n",
            "epoch [60/100], loss: 1.9325, custom_accuracy: 0.3376\n",
            "epoch [61/100], loss: 1.9312, custom_accuracy: 0.3386\n",
            "epoch [62/100], loss: 1.9297, custom_accuracy: 0.3390\n",
            "epoch [63/100], loss: 1.9280, custom_accuracy: 0.3394\n",
            "epoch [64/100], loss: 1.9264, custom_accuracy: 0.3387\n",
            "epoch [65/100], loss: 1.9252, custom_accuracy: 0.3392\n",
            "epoch [66/100], loss: 1.9238, custom_accuracy: 0.3397\n",
            "epoch [67/100], loss: 1.9222, custom_accuracy: 0.3388\n",
            "epoch [68/100], loss: 1.9210, custom_accuracy: 0.3412\n",
            "epoch [69/100], loss: 1.9199, custom_accuracy: 0.3423\n",
            "epoch [70/100], loss: 1.9183, custom_accuracy: 0.3417\n",
            "epoch [71/100], loss: 1.9172, custom_accuracy: 0.3418\n",
            "epoch [72/100], loss: 1.9158, custom_accuracy: 0.3417\n",
            "epoch [73/100], loss: 1.9150, custom_accuracy: 0.3447\n",
            "epoch [74/100], loss: 1.9137, custom_accuracy: 0.3451\n",
            "epoch [75/100], loss: 1.9124, custom_accuracy: 0.3431\n",
            "epoch [76/100], loss: 1.9113, custom_accuracy: 0.3451\n",
            "epoch [77/100], loss: 1.9099, custom_accuracy: 0.3465\n",
            "epoch [78/100], loss: 1.9089, custom_accuracy: 0.3448\n",
            "epoch [79/100], loss: 1.9079, custom_accuracy: 0.3459\n",
            "epoch [80/100], loss: 1.9066, custom_accuracy: 0.3465\n",
            "epoch [81/100], loss: 1.9056, custom_accuracy: 0.3475\n",
            "epoch [82/100], loss: 1.9046, custom_accuracy: 0.3460\n",
            "epoch [83/100], loss: 1.9037, custom_accuracy: 0.3467\n",
            "epoch [84/100], loss: 1.9028, custom_accuracy: 0.3478\n",
            "epoch [85/100], loss: 1.9017, custom_accuracy: 0.3472\n",
            "epoch [86/100], loss: 1.9008, custom_accuracy: 0.3470\n",
            "epoch [87/100], loss: 1.8998, custom_accuracy: 0.3480\n",
            "epoch [88/100], loss: 1.8988, custom_accuracy: 0.3479\n",
            "epoch [89/100], loss: 1.8977, custom_accuracy: 0.3489\n",
            "epoch [90/100], loss: 1.8968, custom_accuracy: 0.3496\n",
            "epoch [91/100], loss: 1.8961, custom_accuracy: 0.3500\n",
            "epoch [92/100], loss: 1.8950, custom_accuracy: 0.3500\n",
            "epoch [93/100], loss: 1.8943, custom_accuracy: 0.3496\n",
            "epoch [94/100], loss: 1.8934, custom_accuracy: 0.3508\n",
            "epoch [95/100], loss: 1.8926, custom_accuracy: 0.3505\n",
            "epoch [96/100], loss: 1.8915, custom_accuracy: 0.3503\n",
            "epoch [97/100], loss: 1.8910, custom_accuracy: 0.3501\n",
            "epoch [98/100], loss: 1.8900, custom_accuracy: 0.3517\n",
            "epoch [99/100], loss: 1.8893, custom_accuracy: 0.3517\n",
            "epoch [100/100], loss: 1.8885, custom_accuracy: 0.3513\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'accuracy vs # epoch: learning rate 0.0001, with no bias')"
            ]
          },
          "metadata": {},
          "execution_count": 11
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}