Part 1 - Intro.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNgdNIt2w1jrw0BFQymL1Gr",
      "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/github/sahal-mulki/learning-pytorch/blob/main/Part%201%20-%20Intro.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# My first notebook made while trying to learn PyTorch!"
      ],
      "metadata": {
        "id": "dHpL_oKukEVt"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MO_steARjTVR",
        "outputId": "8a953bdf-589e-4427-aee7-26d702570b98"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[31mERROR: Operation cancelled by user\u001b[0m\u001b[31m\n",
            "\u001b[0m"
          ]
        }
      ],
      "source": [
        "# CREATED IN PART USING THE GEMINI AI FUNCTION IN COLAB\n",
        "\n",
        "!pip install --upgrade torch torchvision"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "z = torch.zeros(2, 3)\n",
        "print(z)\n",
        "print(\"Z has the type:\")\n",
        "print(z.dtype)\n",
        "\n",
        "ones = torch.ones((2, 3), dtype=torch.int16)\n",
        "\n",
        "print(\"Ones has the type:\")\n",
        "print(ones.type)\n",
        "print(ones)\n",
        "\n",
        "torch.manual_seed(1234)\n",
        "r1 = torch.rand((2, 2), dtype=torch.float16)\n",
        "print('A random tensor:')\n",
        "print(r1)\n",
        "\n",
        "r2 = torch.rand((2, 2), dtype=torch.float16)\n",
        "print('A different random tensor:')\n",
        "print(r2)\n",
        "\n",
        "torch.manual_seed(1234)\n",
        "r3 = torch.rand((2, 2), dtype=torch.float16)\n",
        "print('Should match r1:')\n",
        "print(r3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oLjoSmk2j9Ka",
        "outputId": "c889680d-92e7-4ba1-ec95-b05e631b40da"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[0., 0., 0.],\n",
            "        [0., 0., 0.]])\n",
            "Z has the type:\n",
            "torch.float32\n",
            "Ones has the type:\n",
            "<built-in method type of Tensor object at 0x791f9482d800>\n",
            "tensor([[1, 1, 1],\n",
            "        [1, 1, 1]], dtype=torch.int16)\n",
            "A random tensor:\n",
            "tensor([[0.3979, 0.3530],\n",
            "        [0.6436, 0.5259]], dtype=torch.float16)\n",
            "A different random tensor:\n",
            "tensor([[0.5996, 0.6816],\n",
            "        [0.3242, 0.9966]], dtype=torch.float16)\n",
            "Should match r1:\n",
            "tensor([[0.3979, 0.3530],\n",
            "        [0.6436, 0.5259]], dtype=torch.float16)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ones = torch.ones((2, 3), dtype=torch.int16)\n",
        "print(ones)\n",
        "\n",
        "fours = torch.ones((2, 3), dtype=torch.int16) * 4\n",
        "print(fours)\n",
        "\n",
        "fives = ones + fours\n",
        "print(fives)\n",
        "print(fives.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IdmDnJxak4d3",
        "outputId": "2cb08f9a-8210-4d22-8d91-e792353ffa5f"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[1, 1, 1],\n",
            "        [1, 1, 1]], dtype=torch.int16)\n",
            "tensor([[4, 4, 4],\n",
            "        [4, 4, 4]], dtype=torch.int16)\n",
            "tensor([[5, 5, 5],\n",
            "        [5, 5, 5]], dtype=torch.int16)\n",
            "torch.Size([2, 3])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "pytorch seed changes everytime with new random call??"
      ],
      "metadata": {
        "id": "y3ZeeSfHnSO_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "torch.seed()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pEUYJ9v1mlna",
        "outputId": "8ced4dd4-e316-468d-c1c7-217012dcdb8e"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "17295900731922219800"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fours = torch.ones((2, 3), dtype=torch.int16) * 4"
      ],
      "metadata": {
        "id": "iggNdHP7nMw_"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "r3 = r1 + r2"
      ],
      "metadata": {
        "id": "9l7FJ3FZovyP"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "torch.seed()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VUia_V-lnPA7",
        "outputId": "fe0aef91-53f5-4301-8df6-b54ce4b6062b"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "85034306175053947"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "random_between_1_and_1 = torch.rand(2, 2) - 0.5 * 2\n",
        "print(random_between_1_and_1)\n",
        "\n",
        "print(torch.abs(random_between_1_and_1))\n",
        "\n",
        "print(torch.asin(random_between_1_and_1))\n",
        "\n",
        "print(torch.det(random_between_1_and_1))\n",
        "\n",
        "print(torch.svd(random_between_1_and_1))\n",
        "\n",
        "print(torch.std_mean(random_between_1_and_1))\n",
        "\n",
        "print(torch.max(random_between_1_and_1))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q7DY2_Nxo0Vs",
        "outputId": "89c554ba-80ed-449d-ad8f-053d9778845b"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[-0.4142, -0.7675],\n",
            "        [-0.7479, -0.6860]])\n",
            "tensor([[0.4142, 0.7675],\n",
            "        [0.7479, 0.6860]])\n",
            "tensor([[-0.4271, -0.8750],\n",
            "        [-0.8450, -0.7560]])\n",
            "tensor(-0.2899)\n",
            "torch.return_types.svd(\n",
            "U=tensor([[-0.6485, -0.7613],\n",
            "        [-0.7613,  0.6485]]),\n",
            "S=tensor([1.3200, 0.2196]),\n",
            "V=tensor([[ 0.6348, -0.7727],\n",
            "        [ 0.7727,  0.6348]]))\n",
            "(tensor(0.1635), tensor(-0.6539))\n",
            "tensor(-0.4142)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.nn as nn\n",
        "import torch.nn.functional as F"
      ],
      "metadata": {
        "id": "t-mS_jB0qRSC"
      },
      "execution_count": 42,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class MulkiNet(nn.Module):\n",
        "\n",
        "    def __init__(self):\n",
        "        super(MulkiNet, self).__init__()\n",
        "        # 3 input image channel (rgb), 6 output channels, 8*8 square convolution\n",
        "        # kernel\n",
        "        self.conv1 = nn.Conv2d(3, 6, 8)\n",
        "        self.conv2 = nn.Conv2d(6, 16, 4)\n",
        "        # an affine operation: y = Wx + b\n",
        "        self.fc1 = nn.Linear(16 * 4 * 4, 256)  # 4*4 from image dimension\n",
        "        self.fc2 = nn.Linear(256, 64)\n",
        "        self.fc3 = nn.Linear(64, 10)\n",
        "\n",
        "    def forward(self, x):\n",
        "        # Max pooling over a (2, 2) window\n",
        "        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))\n",
        "        # If the size is a square you can only specify a single number\n",
        "        x = F.max_pool2d(F.relu(self.conv2(x)), 2)\n",
        "        x = x.view(-1, self.num_flat_features(x))\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = F.relu(self.fc2(x))\n",
        "        x = self.fc3(x)\n",
        "        return x\n",
        "\n",
        "    def num_flat_features(self, x):\n",
        "        size = x.size()[1:]  # all dimensions except the batch dimension\n",
        "        num_features = 1\n",
        "        for s in size:\n",
        "            num_features *= s\n",
        "        return num_features\n",
        "\n",
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Net, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(3, 6, 5)\n",
        "        self.pool = nn.MaxPool2d(2, 2)\n",
        "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
        "        self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
        "        self.fc2 = nn.Linear(120, 84)\n",
        "        self.fc3 = nn.Linear(84, 10)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.pool(F.relu(self.conv1(x)))\n",
        "        x = self.pool(F.relu(self.conv2(x)))\n",
        "        x = x.view(-1, 16 * 5 * 5)\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = F.relu(self.fc2(x))\n",
        "        x = self.fc3(x)\n",
        "        return x"
      ],
      "metadata": {
        "id": "5_9fL49ktRNZ"
      },
      "execution_count": 116,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "net = MulkiNet()\n",
        "\n",
        "print(net)\n",
        "\n",
        "lenet = Net()\n",
        "\n",
        "print(lenet)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-Mprh_cWtbZH",
        "outputId": "12577c18-abb6-427c-a59a-acbd44f431b4"
      },
      "execution_count": 118,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MulkiNet(\n",
            "  (conv1): Conv2d(3, 6, kernel_size=(8, 8), stride=(1, 1))\n",
            "  (conv2): Conv2d(6, 16, kernel_size=(4, 4), stride=(1, 1))\n",
            "  (fc1): Linear(in_features=256, out_features=256, bias=True)\n",
            "  (fc2): Linear(in_features=256, out_features=64, bias=True)\n",
            "  (fc3): Linear(in_features=64, out_features=10, bias=True)\n",
            ")\n",
            "Net(\n",
            "  (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))\n",
            "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
            "  (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
            "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
            "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
            ")\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "input = torch.rand(1, 3, 32, 32)   # stand-in for a 32x32 black & white image\n",
        "print('Image batch shape:')\n",
        "print(input.shape)\n",
        "\n",
        "output = net(input)                # we don't call forward() directly\n",
        "print('\\nRaw output:')\n",
        "print(output)\n",
        "print(output.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QMrtPN_Stn7p",
        "outputId": "97fbe3a5-b997-46a1-8444-0c61f8369793"
      },
      "execution_count": 119,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Image batch shape:\n",
            "torch.Size([1, 3, 32, 32])\n",
            "\n",
            "Raw output:\n",
            "tensor([[ 0.0409, -0.1029, -0.0650,  0.0256, -0.0195, -0.1420, -0.0448, -0.0763,\n",
            "         -0.1250,  0.0721]], grad_fn=<AddmmBackward0>)\n",
            "torch.Size([1, 10])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%matplotlib inline"
      ],
      "metadata": {
        "id": "Y76BE7wFueAZ"
      },
      "execution_count": 113,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torchvision\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import torchvision.transforms as transforms\n",
        "\n",
        "# show an image\n",
        "def show(img):\n",
        "    npimg = img.numpy()\n",
        "    plt.imshow(np.transpose(npimg, (1, 2, 0)), interpolation='nearest')"
      ],
      "metadata": {
        "id": "lMeNOg4UyJc_"
      },
      "execution_count": 114,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "show(torchvision.utils.make_grid(input))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 450
        },
        "id": "0SeAY3i1yN1I",
        "outputId": "3ccc98bb-8212-4238-e66c-0f96fe57f8eb"
      },
      "execution_count": 120,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "transform = transforms.Compose(\n",
        "    [transforms.ToTensor(),\n",
        "     transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2470, 0.2435, 0.2616))])"
      ],
      "metadata": {
        "id": "NWuUmSAryQge"
      },
      "execution_count": 103,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "trainset = torchvision.datasets.CIFAR10(root='./data', train=True,download=True, transform=transform)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S99UcrGSyglW",
        "outputId": "6d0a5e81-c988-469a-e15e-c0efaeddf0f1"
      },
      "execution_count": 104,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 170498071/170498071 [00:02<00:00, 59123403.46it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/cifar-10-python.tar.gz to ./data\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,\n",
        "                                          shuffle=True, num_workers=2)\n"
      ],
      "metadata": {
        "id": "FCOAAEriyxEv"
      },
      "execution_count": 105,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "classes = ('plane', 'car', 'bird', 'cat',\n",
        "           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n",
        "\n",
        "def imshow(img):\n",
        "    img = img / 2 + 0.5     # unnormalize\n",
        "    npimg = img.numpy()\n",
        "    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
        "\n",
        "\n",
        "# get some random training images\n",
        "dataiter = iter(trainloader)\n",
        "images, labels = next(dataiter)\n",
        "\n",
        "# show images\n",
        "imshow(torchvision.utils.make_grid(images))\n",
        "# print labels\n",
        "print(' '.join('%5s' % classes[labels[j]] for j in range(4)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 248
        },
        "id": "oB__c3su1HK2",
        "outputId": "4ad1da13-1c21-46f9-90e4-1f80af637239"
      },
      "execution_count": 107,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " ship horse horse  bird\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.optim as optim"
      ],
      "metadata": {
        "id": "5grZe5Ax1ZjO"
      },
      "execution_count": 124,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)"
      ],
      "metadata": {
        "id": "REE1BocX17nG"
      },
      "execution_count": 125,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for epoch in range(2):  # loop over the dataset multiple times\n",
        "\n",
        "    running_loss = 0.0\n",
        "    for i, data in enumerate(trainloader, 0):\n",
        "        # get the inputs\n",
        "        inputs, labels = data\n",
        "\n",
        "        # zero the parameter gradients\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        # forward + backward + optimize\n",
        "        outputs = lenet(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        # print statistics\n",
        "        running_loss += loss.item()\n",
        "        if i % 2000 == 1999:    # print every 2000 mini-batches\n",
        "            print('[%d, %5d] loss: %.3f' %\n",
        "                  (epoch + 1, i + 1, running_loss / 2000))\n",
        "            running_loss = 0.0\n",
        "\n",
        "print('Finished Training')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4yA1L90K2ZDq",
        "outputId": "25383a9d-b398-40c3-8868-47b8ac712e04"
      },
      "execution_count": 127,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1,  2000] loss: 2.304\n",
            "[1,  4000] loss: 2.304\n",
            "[1,  6000] loss: 2.305\n",
            "[1,  8000] loss: 2.306\n",
            "[1, 10000] loss: 2.305\n",
            "[1, 12000] loss: 2.305\n",
            "[2,  2000] loss: 2.305\n",
            "[2,  4000] loss: 2.305\n",
            "[2,  6000] loss: 2.304\n",
            "[2,  8000] loss: 2.305\n",
            "[2, 10000] loss: 2.304\n",
            "[2, 12000] loss: 2.306\n",
            "Finished Training\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for epoch in range(2):  # loop over the dataset multiple times\n",
        "\n",
        "    running_loss = 0.0\n",
        "    for i, data in enumerate(trainloader, 0):\n",
        "        # get the inputs\n",
        "        inputs, labels = data\n",
        "\n",
        "        # zero the parameter gradients\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        # forward + backward + optimize\n",
        "        outputs = net(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        # print statistics\n",
        "        running_loss += loss.item()\n",
        "        if i % 2000 == 1999:    # print every 2000 mini-batches\n",
        "            print('[%d, %5d] loss: %.3f' %\n",
        "                  (epoch + 1, i + 1, running_loss / 2000))\n",
        "            running_loss = 0.0\n",
        "\n",
        "print('Finished Training')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZPgWlI2s2nX5",
        "outputId": "584c5df2-1e19-457f-caca-3a2f24e649ca"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1,  2000] loss: 1.333\n",
            "[1,  4000] loss: 1.337\n",
            "[1,  6000] loss: 1.361\n",
            "[1,  8000] loss: 1.336\n",
            "[1, 10000] loss: 1.332\n",
            "[1, 12000] loss: 1.322\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "-RnT-zdA9ah6"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}