1、安装、使用

（1）安装

  • 选择与自己机器相匹配的平台进行安装
    • It is recommended that you use Python 3.6, 3.7 or 3.8.
    • 参考：https://pytorch.org/get-started/locally/
    • pip3 install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu113

image.png

（2）使用测试

  1. import torch
  2. x = torch.rand(5, 3)
  3. print(x)
  5. """
  6. tensor([[0.3380, 0.3845, 0.3217],
  7.         [0.8337, 0.9050, 0.2650],
  8.         [0.2979, 0.7141, 0.9069],
  9.         [0.1449, 0.1132, 0.1375],
  10.         [0.4675, 0.3947, 0.1426]])
  11. """
  13. # jy: 判断是否为 GPU 环境对应的 torch 版本
  14. is_gpu = torch.cuda.is_available()
  15. print(is_gpu)

2、基本介绍

  • PyTorch is an open source machine learning framework.
  • Most machine learning workflows involve working with data, creating models, optimizing model parameters, and saving the trained models. This tutorial introduces you to a complete ML workflow implemented in PyTorch, with links to learn more about each of these concepts.

  • We’ll use the FashionMNIST dataset to train a neural network that predicts if an input image belongs to one of the following classes: T-shirt/top, Trouser, Pullover, Dress, Coat, Sandal, Shirt, Sneaker, Bag, or Ankle boot.

    • This tutorial assumes a basic familiarity with Python and Deep Learning concepts.

      3、QuickStart

  • This section runs through the API for common tasks in machine learning.

    （1）Working with data

  • PyTorch has two primitives to work with data: torch.utils.data.DataLoader and torch.utils.data.Dataset.

  • PyTorch offers domain-specific libraries such as TorchText, TorchVision, and TorchAudio, all of which include datasets. For this tutorial, we will be using a TorchVision dataset.
  • The torchvision.datasets module contains Dataset objects for many real-world vision data like CIFAR, COCO. In this tutorial, we use the FashionMNIST dataset. Every TorchVision Dataset includes two arguments: transform and target_transform to modify the samples and labels respectively.
  • We pass the Dataset as an argument to DataLoader. This wraps an iterable over our dataset, and supports automatic batching, sampling, shuffling and multiprocess data loading. Here we define a batch size of 64, i.e. each element in the dataloader iterable will return a batch of 64 features and labels. ```python import torch from torch import nn from torch.utils.data import DataLoader from torchvision import datasets from torchvision.transforms import ToTensor

Download training data from open datasets.

training_data = datasets.FashionMNIST( root=”data”, train=True, download=True, transform=ToTensor(), )

Download test data from open datasets.

test_data = datasets.FashionMNIST( root=”data”, train=False, download=True, transform=ToTensor(), )

batch_size = 64

Create data loaders.

train_dataloader = DataLoader(training_data, batch_size=batch_size) test_dataloader = DataLoader(test_data, batch_size=batch_size)

for X, y in test_dataloader: print(f”Shape of X [N, C, H, W]: {X.shape}”) print(f”Shape of y: {y.shape} {y.dtype}”) break

  1. <a name="yql4Y"></a>
  2. ## （2）Creating Models
  4. - To define a neural network in PyTorch, we create a class that inherits from `nn.Module`. We define the layers of the network in the `__init__` function and specify how data will pass through the network in the `forward` function. To accelerate operations in the neural network, we move it to the GPU if available.
  5.    - `nn.Module`：[https://pytorch.org/docs/stable/generated/torch.nn.Module.html](https://pytorch.org/docs/stable/generated/torch.nn.Module.html)
  6. ```python
  7. # Get cpu or gpu device for training.
  8. device = "cuda" if torch.cuda.is_available() else "cpu"
  9. print(f"Using {device} device")
  11. # Define model
  12. class NeuralNetwork(nn.Module):
  13.     def __init__(self):
  14.         super(NeuralNetwork, self).__init__()
  15.         self.flatten = nn.Flatten()
  16.         self.linear_relu_stack = nn.Sequential(
  17.             nn.Linear(28*28, 512),
  18.             nn.ReLU(),
  19.             nn.Linear(512, 512),
  20.             nn.ReLU(),
  21.             nn.Linear(512, 10)
  22.         )
  24.     def forward(self, x):
  25.         x = self.flatten(x)
  26.         logits = self.linear_relu_stack(x)
  27.         return logits
  29. model = NeuralNetwork().to(device)
  30. print(model)

（3）Optimizing the Model Parameters

  • To train a model, we need a loss function and an optimizer.

  • In a single training loop, the model makes predictions on the training dataset (fed to it in batches), and backpropagates the prediction error to adjust the model’s parameters.

    1. def train(dataloader, model, loss_fn, optimizer):
    2.   size = len(dataloader.dataset)
    3.   model.train()
    4.   for batch, (X, y) in enumerate(dataloader):
    5.       X, y = X.to(device), y.to(device)
    7.       # Compute prediction error
    8.       pred = model(X)
    9.       loss = loss_fn(pred, y)
    11.       # Backpropagation
    12.       optimizer.zero_grad()
    13.       loss.backward()
    14.       optimizer.step()
    16.       if batch % 100 == 0:
    17.           loss, current = loss.item(), batch * len(X)
    18.           print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")

  • We also check the model’s performance against the test dataset to ensure it is learning.

    1. def test(dataloader, model, loss_fn):
    2.   size = len(dataloader.dataset)
    3.   num_batches = len(dataloader)
    4.   model.eval()
    5.   test_loss, correct = 0, 0
    6.   with torch.no_grad():
    7.       for X, y in dataloader:
    8.           X, y = X.to(device), y.to(device)
    9.           pred = model(X)
    10.           test_loss += loss_fn(pred, y).item()
    11.           correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    12.   test_loss /= num_batches
    13.   correct /= size
    14.   print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, 
    15.         Avg loss: {test_loss:>8f} \n")

  • The training process is conducted over several iterations (epochs). During each epoch, the model learns parameters to make better predictions. We print the model’s accuracy and loss at each epoch; we’d like to see the accuracy increase and the loss decrease with every epoch.

    1. epochs = 5
    2. for t in range(epochs):
    3.   print(f"Epoch {t+1}\n-------------------------------")
    4.   train(train_dataloader, model, loss_fn, optimizer)
    5.   test(test_dataloader, model, loss_fn)
    6. print("Done!")

    （4）Saving Models

  • A common way to save a model is to serialize the internal state dictionary (containing the model parameters).

    1. torch.save(model.state_dict(), "model.pth")
    2. print("Saved PyTorch Model State to model.pth")

    （5）Loading Models

  • The process for loading a model includes re-creating the model structure and loading the state dictionary into it. When the model is loaded, it can be used to make predictions. ```python model = NeuralNetwork() model.load_state_dict(torch.load(“model.pth”))

classes = [ “T-shirt/top”, “Trouser”, “Pullover”, “Dress”, “Coat”, “Sandal”, “Shirt”, “Sneaker”, “Bag”, “Ankle boot”, ]

model.eval() x, y = test_data[0][0], test_data[0][1] with torch.no_grad(): pred = model(x) predicted, actual = classes[pred[0].argmax(0)], classes[y] print(f’Predicted: “{predicted}”, Actual: “{actual}”‘)

  1. <a name="rE3gv"></a>
  2. # 9、问题汇总
  3. <a name="B8WGD"></a>
  4. ## （1）使用 torch 报错：no kernel image is available
  6. - RuntimeError: CUDA error: no kernel image is available for execution on the device
  7. ```python
  8. import torch
  10. print(torch.cuda.is_available()) # True
  11. a = torch.Tensor([1,2])
  12. a = a.cuda()
  13. print(a)
  • 原因：torch 安装的各依赖版本不兼容，更新 torch 相关版本即可：
    1. conda uninstall *torch* cudatoolkit
    2. pip3 install torch==1.10.2+cu113 torchvision==0.11.3+cu113 torchaudio==0.10.2+cu113 -f https://download.pytorch.org/whl/cu113/torch_stable.html