summaryrefslogtreecommitdiff
path: root/.ipynb_checkpoints/quickstart_tutorial-checkpoint.ipynb
diff options
context:
space:
mode:
Diffstat (limited to '.ipynb_checkpoints/quickstart_tutorial-checkpoint.ipynb')
-rw-r--r--.ipynb_checkpoints/quickstart_tutorial-checkpoint.ipynb645
1 files changed, 0 insertions, 645 deletions
diff --git a/.ipynb_checkpoints/quickstart_tutorial-checkpoint.ipynb b/.ipynb_checkpoints/quickstart_tutorial-checkpoint.ipynb
deleted file mode 100644
index 55d4021..0000000
--- a/.ipynb_checkpoints/quickstart_tutorial-checkpoint.ipynb
+++ /dev/null
@@ -1,645 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false,
- "jupyter": {
- "outputs_hidden": false
- }
- },
- "outputs": [],
- "source": [
- "%matplotlib inline"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "`Learn the Basics <intro.html>`_ ||\n",
- "**Quickstart** ||\n",
- "`Tensors <tensorqs_tutorial.html>`_ ||\n",
- "`Datasets & DataLoaders <data_tutorial.html>`_ ||\n",
- "`Transforms <transforms_tutorial.html>`_ ||\n",
- "`Build Model <buildmodel_tutorial.html>`_ ||\n",
- "`Autograd <autogradqs_tutorial.html>`_ ||\n",
- "`Optimization <optimization_tutorial.html>`_ ||\n",
- "`Save & Load Model <saveloadrun_tutorial.html>`_\n",
- "\n",
- "Quickstart\n",
- "===================\n",
- "This section runs through the API for common tasks in machine learning. Refer to the links in each section to dive deeper.\n",
- "\n",
- "Working with data\n",
- "-----------------\n",
- "PyTorch has two `primitives to work with data <https://pytorch.org/docs/stable/data.html>`_:\n",
- "``torch.utils.data.DataLoader`` and ``torch.utils.data.Dataset``.\n",
- "``Dataset`` stores the samples and their corresponding labels, and ``DataLoader`` wraps an iterable around\n",
- "the ``Dataset``.\n",
- "\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {
- "collapsed": false,
- "jupyter": {
- "outputs_hidden": false
- }
- },
- "outputs": [],
- "source": [
- "import torch\n",
- "from torch import nn\n",
- "from torch.utils.data import DataLoader\n",
- "from torchvision import datasets\n",
- "from torchvision.transforms import ToTensor, Lambda, Compose\n",
- "import matplotlib.pyplot as plt"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "PyTorch offers domain-specific libraries such as `TorchText <https://pytorch.org/text/stable/index.html>`_,\n",
- "`TorchVision <https://pytorch.org/vision/stable/index.html>`_, and `TorchAudio <https://pytorch.org/audio/stable/index.html>`_,\n",
- "all of which include datasets. For this tutorial, we will be using a TorchVision dataset.\n",
- "\n",
- "The ``torchvision.datasets`` module contains ``Dataset`` objects for many real-world vision data like\n",
- "CIFAR, COCO (`full list here <https://pytorch.org/vision/stable/datasets.html>`_). In this tutorial, we\n",
- "use the FashionMNIST dataset. Every TorchVision ``Dataset`` includes two arguments: ``transform`` and\n",
- "``target_transform`` to modify the samples and labels respectively.\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {
- "collapsed": false,
- "jupyter": {
- "outputs_hidden": false
- }
- },
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/home/ta180m/git/PyTorch/.venv/lib/python3.9/site-packages/torchvision/datasets/mnist.py:498: UserWarning: The given NumPy array is not writeable, and PyTorch does not support non-writeable tensors. This means you can write to the underlying (supposedly non-writeable) NumPy array using the tensor. You may want to copy the array to protect its data or make it writeable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at /pytorch/torch/csrc/utils/tensor_numpy.cpp:180.)\n",
- " return torch.from_numpy(parsed.astype(m[2], copy=False)).view(*s)\n"
- ]
- }
- ],
- "source": [
- "# Download training data from open datasets.\n",
- "training_data = datasets.FashionMNIST(\n",
- " root=\"data\",\n",
- " train=True,\n",
- " download=True,\n",
- " transform=ToTensor(),\n",
- ")\n",
- "\n",
- "# Download test data from open datasets.\n",
- "test_data = datasets.FashionMNIST(\n",
- " root=\"data\",\n",
- " train=False,\n",
- " download=True,\n",
- " transform=ToTensor(),\n",
- ")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "We pass the ``Dataset`` as an argument to ``DataLoader``. This wraps an iterable over our dataset, and supports\n",
- "automatic batching, sampling, shuffling and multiprocess data loading. Here we define a batch size of 64, i.e. each element\n",
- "in the dataloader iterable will return a batch of 64 features and labels.\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {
- "collapsed": false,
- "jupyter": {
- "outputs_hidden": false
- }
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Shape of X [N, C, H, W]: torch.Size([64, 1, 28, 28])\n",
- "Shape of y: torch.Size([64]) torch.int64\n"
- ]
- }
- ],
- "source": [
- "batch_size = 64\n",
- "\n",
- "# Create data loaders.\n",
- "train_dataloader = DataLoader(training_data, batch_size=batch_size)\n",
- "test_dataloader = DataLoader(test_data, batch_size=batch_size)\n",
- "\n",
- "for X, y in test_dataloader:\n",
- " print(\"Shape of X [N, C, H, W]: \", X.shape)\n",
- " print(\"Shape of y: \", y.shape, y.dtype)\n",
- " break"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Read more about `loading data in PyTorch <data_tutorial.html>`_.\n",
- "\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "--------------\n",
- "\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Creating Models\n",
- "------------------\n",
- "To define a neural network in PyTorch, we create a class that inherits\n",
- "from `nn.Module <https://pytorch.org/docs/stable/generated/torch.nn.Module.html>`_. We define the layers of the network\n",
- "in the ``__init__`` function and specify how data will pass through the network in the ``forward`` function. To accelerate\n",
- "operations in the neural network, we move it to the GPU if available.\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {
- "collapsed": false,
- "jupyter": {
- "outputs_hidden": false
- }
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Using cpu device\n",
- "NeuralNetwork(\n",
- " (flatten): Flatten(start_dim=1, end_dim=-1)\n",
- " (linear_relu_stack): Sequential(\n",
- " (0): Linear(in_features=784, out_features=512, bias=True)\n",
- " (1): ReLU()\n",
- " (2): Linear(in_features=512, out_features=512, bias=True)\n",
- " (3): ReLU()\n",
- " (4): Linear(in_features=512, out_features=10, bias=True)\n",
- " (5): ReLU()\n",
- " )\n",
- ")\n"
- ]
- }
- ],
- "source": [
- "# Get cpu or gpu device for training.\n",
- "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
- "print(\"Using {} device\".format(device))\n",
- "\n",
- "# Define model\n",
- "class NeuralNetwork(nn.Module):\n",
- " def __init__(self):\n",
- " super(NeuralNetwork, self).__init__()\n",
- " self.flatten = nn.Flatten()\n",
- " self.linear_relu_stack = nn.Sequential(\n",
- " nn.Linear(28*28, 512),\n",
- " nn.ReLU(),\n",
- " nn.Linear(512, 512),\n",
- " nn.ReLU(),\n",
- " nn.Linear(512, 10),\n",
- " nn.ReLU()\n",
- " )\n",
- "\n",
- " def forward(self, x):\n",
- " x = self.flatten(x)\n",
- " logits = self.linear_relu_stack(x)\n",
- " return logits\n",
- "\n",
- "model = NeuralNetwork().to(device)\n",
- "print(model)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Read more about `building neural networks in PyTorch <buildmodel_tutorial.html>`_.\n",
- "\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "--------------\n",
- "\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Optimizing the Model Parameters\n",
- "----------------------------------------\n",
- "To train a model, we need a `loss function <https://pytorch.org/docs/stable/nn.html#loss-functions>`_\n",
- "and an `optimizer <https://pytorch.org/docs/stable/optim.html>`_.\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {
- "collapsed": false,
- "jupyter": {
- "outputs_hidden": false
- }
- },
- "outputs": [],
- "source": [
- "loss_fn = nn.CrossEntropyLoss()\n",
- "optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "In a single training loop, the model makes predictions on the training dataset (fed to it in batches), and\n",
- "backpropagates the prediction error to adjust the model's parameters.\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {
- "collapsed": false,
- "jupyter": {
- "outputs_hidden": false
- }
- },
- "outputs": [],
- "source": [
- "def train(dataloader, model, loss_fn, optimizer):\n",
- " size = len(dataloader.dataset)\n",
- " for batch, (X, y) in enumerate(dataloader):\n",
- " X, y = X.to(device), y.to(device)\n",
- "\n",
- " # Compute prediction error\n",
- " pred = model(X)\n",
- " loss = loss_fn(pred, y)\n",
- "\n",
- " # Backpropagation\n",
- " optimizer.zero_grad()\n",
- " loss.backward()\n",
- " optimizer.step()\n",
- "\n",
- " if batch % 100 == 0:\n",
- " loss, current = loss.item(), batch * len(X)\n",
- " print(f\"loss: {loss:>7f} [{current:>5d}/{size:>5d}]\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "We also check the model's performance against the test dataset to ensure it is learning.\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {
- "collapsed": false,
- "jupyter": {
- "outputs_hidden": false
- }
- },
- "outputs": [],
- "source": [
- "def test(dataloader, model, loss_fn):\n",
- " size = len(dataloader.dataset)\n",
- " num_batches = len(dataloader)\n",
- " model.eval()\n",
- " test_loss, correct = 0, 0\n",
- " with torch.no_grad():\n",
- " for X, y in dataloader:\n",
- " X, y = X.to(device), y.to(device)\n",
- " pred = model(X)\n",
- " test_loss += loss_fn(pred, y).item()\n",
- " correct += (pred.argmax(1) == y).type(torch.float).sum().item()\n",
- " test_loss /= num_batches\n",
- " correct /= size\n",
- " print(f\"Test Error: \\n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \\n\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "The training process is conducted over several iterations (*epochs*). During each epoch, the model learns\n",
- "parameters to make better predictions. We print the model's accuracy and loss at each epoch; we'd like to see the\n",
- "accuracy increase and the loss decrease with every epoch.\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "metadata": {
- "collapsed": false,
- "jupyter": {
- "outputs_hidden": false
- }
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Epoch 1\n",
- "-------------------------------\n",
- "loss: 2.300270 [ 0/60000]\n",
- "loss: 2.290948 [ 6400/60000]\n",
- "loss: 2.280627 [12800/60000]\n",
- "loss: 2.283042 [19200/60000]\n",
- "loss: 2.268817 [25600/60000]\n",
- "loss: 2.262104 [32000/60000]\n",
- "loss: 2.248093 [38400/60000]\n",
- "loss: 2.233517 [44800/60000]\n",
- "loss: 2.234299 [51200/60000]\n",
- "loss: 2.234841 [57600/60000]\n",
- "Test Error: \n",
- " Accuracy: 51.1%, Avg loss: 2.221716 \n",
- "\n",
- "Epoch 2\n",
- "-------------------------------\n",
- "loss: 2.203925 [ 0/60000]\n",
- "loss: 2.200477 [ 6400/60000]\n",
- "loss: 2.180246 [12800/60000]\n",
- "loss: 2.213840 [19200/60000]\n",
- "loss: 2.155768 [25600/60000]\n",
- "loss: 2.154045 [32000/60000]\n",
- "loss: 2.130811 [38400/60000]\n",
- "loss: 2.101326 [44800/60000]\n",
- "loss: 2.118105 [51200/60000]\n",
- "loss: 2.116674 [57600/60000]\n",
- "Test Error: \n",
- " Accuracy: 51.0%, Avg loss: 2.093179 \n",
- "\n",
- "Epoch 3\n",
- "-------------------------------\n",
- "loss: 2.054594 [ 0/60000]\n",
- "loss: 2.047193 [ 6400/60000]\n",
- "loss: 2.009665 [12800/60000]\n",
- "loss: 2.093936 [19200/60000]\n",
- "loss: 1.965194 [25600/60000]\n",
- "loss: 1.976750 [32000/60000]\n",
- "loss: 1.938592 [38400/60000]\n",
- "loss: 1.889513 [44800/60000]\n",
- "loss: 1.942611 [51200/60000]\n",
- "loss: 1.936963 [57600/60000]\n",
- "Test Error: \n",
- " Accuracy: 51.2%, Avg loss: 1.900150 \n",
- "\n",
- "Epoch 4\n",
- "-------------------------------\n",
- "loss: 1.837173 [ 0/60000]\n",
- "loss: 1.822518 [ 6400/60000]\n",
- "loss: 1.775139 [12800/60000]\n",
- "loss: 1.925843 [19200/60000]\n",
- "loss: 1.731390 [25600/60000]\n",
- "loss: 1.778743 [32000/60000]\n",
- "loss: 1.714922 [38400/60000]\n",
- "loss: 1.670009 [44800/60000]\n",
- "loss: 1.755909 [51200/60000]\n",
- "loss: 1.763030 [57600/60000]\n",
- "Test Error: \n",
- " Accuracy: 52.5%, Avg loss: 1.711389 \n",
- "\n",
- "Epoch 5\n",
- "-------------------------------\n",
- "loss: 1.621799 [ 0/60000]\n",
- "loss: 1.615258 [ 6400/60000]\n",
- "loss: 1.567131 [12800/60000]\n",
- "loss: 1.768921 [19200/60000]\n",
- "loss: 1.539987 [25600/60000]\n",
- "loss: 1.627408 [32000/60000]\n",
- "loss: 1.533756 [38400/60000]\n",
- "loss: 1.510703 [44800/60000]\n",
- "loss: 1.603583 [51200/60000]\n",
- "loss: 1.636089 [57600/60000]\n",
- "Test Error: \n",
- " Accuracy: 53.2%, Avg loss: 1.568043 \n",
- "\n",
- "Done!\n"
- ]
- }
- ],
- "source": [
- "epochs = 5\n",
- "for t in range(epochs):\n",
- " print(f\"Epoch {t+1}\\n-------------------------------\")\n",
- " train(train_dataloader, model, loss_fn, optimizer)\n",
- " test(test_dataloader, model, loss_fn)\n",
- "print(\"Done!\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Read more about `Training your model <optimization_tutorial.html>`_.\n",
- "\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "--------------\n",
- "\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Saving Models\n",
- "-------------\n",
- "A common way to save a model is to serialize the internal state dictionary (containing the model parameters).\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 12,
- "metadata": {
- "collapsed": false,
- "jupyter": {
- "outputs_hidden": false
- }
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Saved PyTorch Model State to model.pth\n"
- ]
- }
- ],
- "source": [
- "torch.save(model.state_dict(), \"model.pth\")\n",
- "print(\"Saved PyTorch Model State to model.pth\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Loading Models\n",
- "----------------------------\n",
- "\n",
- "The process for loading a model includes re-creating the model structure and loading\n",
- "the state dictionary into it.\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 13,
- "metadata": {
- "collapsed": false,
- "jupyter": {
- "outputs_hidden": false
- }
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "<All keys matched successfully>"
- ]
- },
- "execution_count": 13,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "model = NeuralNetwork()\n",
- "model.load_state_dict(torch.load(\"model.pth\"))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "This model can now be used to make predictions.\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 17,
- "metadata": {
- "collapsed": false,
- "jupyter": {
- "outputs_hidden": false
- }
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Predicted: \"Ankle boot\", Actual: \"Ankle boot\"\n"
- ]
- }
- ],
- "source": [
- "classes = [\n",
- " \"T-shirt/top\",\n",
- " \"Trouser\",\n",
- " \"Pullover\",\n",
- " \"Dress\",\n",
- " \"Coat\",\n",
- " \"Sandal\",\n",
- " \"Shirt\",\n",
- " \"Sneaker\",\n",
- " \"Bag\",\n",
- " \"Ankle boot\",\n",
- "]\n",
- "\n",
- "model.eval()\n",
- "x, y = test_data[0][0], test_data[0][1]\n",
- "with torch.no_grad():\n",
- " pred = model(x)\n",
- " predicted, actual = classes[pred[0].argmax(0)], classes[y]\n",
- " print(f'Predicted: \"{predicted}\", Actual: \"{actual}\"')"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Read more about `Saving & Loading your model <saveloadrun_tutorial.html>`_.\n",
- "\n",
- "\n"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "PyTorch",
- "language": "python",
- "name": "pytorch"
- },
- "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.9.6"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
generated by cgit v1.2.3-70-g09d2 (git 2.47.1) at 2024-12-23 00:52:40 +0000