a/PyTorch
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Remove checkpoints from version control

Browse source
This commit is contained in:
Anthony Wang 2021-08-26 21:33:52 -05:00
parent 66ae608860
commit 0e7436a788
4 changed files with 0 additions and 2694 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

43
.ipynb_checkpoints/intro-checkpoint.ipynb
View file

@ -1,43 +0,0 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"%matplotlib inline"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n**Learn the Basics** ||\n`Quickstart <quickstart_tutorial.html>`_ ||\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\nLearn the Basics\n===================\n\nAuthors:\n`Suraj Subramanian <https://github.com/suraj813>`_,\n`Seth Juarez <https://github.com/sethjuarez/>`_,\n`Cassie Breviu <https://github.com/cassieview/>`_,\n`Dmitry Soshnikov <https://soshnikov.com/>`_,\n`Ari Bornstein <https://github.com/aribornstein/>`_\n\nMost machine learning workflows involve working with data, creating models, optimizing model\nparameters, and saving the trained models. This tutorial introduces you to a complete ML workflow\nimplemented in PyTorch, with links to learn more about each of these concepts.\n\nWe'll use the FashionMNIST dataset to train a neural network that predicts if an input image belongs\nto one of the following classes: T-shirt/top, Trouser, Pullover, Dress, Coat, Sandal, Shirt, Sneaker,\nBag, or Ankle boot.\n\n`This tutorial assumes a basic familiarity with Python and Deep Learning concepts.`\n\n\nRunning the Tutorial Code\n------------------\nYou can run this tutorial in a couple of ways:\n\n- **In the cloud**: This is the easiest way to get started! Each section has a \"Run in Microsoft Learn\" link at the top, which opens an integrated notebook in Microsoft Learn with the code in a fully-hosted environment.\n- **Locally**: This option requires you to setup PyTorch and TorchVision first on your local machine (`installation instructions <https://pytorch.org/get-started/locally/>`_). Download the notebook or copy the code into your favorite IDE.\n\n\nHow to Use this Guide\n-----------------\nIf you're familiar with other deep learning frameworks, check out the `0. Quickstart <quickstart_tutorial.html>`_ first\nto quickly familiarize yourself with PyTorch's API.\n\nIf you're new to deep learning frameworks, head right into the first section of our step-by-step guide: `1. Tensors <tensor_tutorial.html>`_.\n\n\n.. include:: /beginner_source/basics/qs_toc.txt\n\n.. toctree::\n :hidden:\n\n\n"
]
}
],
"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.6.13"
}
},
"nbformat": 4,
"nbformat_minor": 0
}

1928
.ipynb_checkpoints/nn_tutorial-checkpoint.ipynb
View file

File diff suppressed because it is too large Load diff

645
.ipynb_checkpoints/quickstart_tutorial-checkpoint.ipynb
View file

@ -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
}

78
.ipynb_checkpoints/test-checkpoint.ipynb
View file

@ -1,78 +0,0 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "5a2a1e37-f4db-4963-a0ac-7b39353f826f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tensor([[0.2226, 0.2227, 0.1347],\n",
" [0.7975, 0.3823, 0.9395],\n",
" [0.1675, 0.9185, 0.4175],\n",
" [0.0476, 0.1244, 0.6878],\n",
" [0.5177, 0.7245, 0.2723]])\n"
]
}
],
"source": [
"import torch\n",
"x = torch.rand(5, 3)\n",
"print(x)"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "53469c52-9438-4d62-aa2a-e93fb3fef23b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"torch.cuda.is_available()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f13c7010-acb0-4870-aa6f-1294701cfc7e",
"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.9.6"
}
},
"nbformat": 4,
"nbformat_minor": 5
}