了解Pytorch|Get Started with PyTorch

一个开源的机器学习框架，加速了从研究原型到生产部署的路径。
!pip install torch -i https://pypi.tuna.tsinghua.edu.cn/simple

import torch import numpy as np 

Basics

就像Tensorflow一样，我们也将继续在PyTorch中玩转Tensors。

从数据（列表）中创建张量

data = [[1, 2],[3, 4]] tensors = torch.tensor(data) 

tensors 

tensor([[1, 2],
[3, 4]])

从NumPy创建

np_array = np.arange(10) tensor_np = torch.from_numpy(np_array) 

tensor_np 

tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=torch.int32)

形状、ndim和dtype

这与我们在《Numpy教程--第1天》中看到的相同。

tensor_np.shape 

torch.Size([10])

tensor_np.ndim 

1

tensor_np.dtype 

torch.int32

张量操作（Tensor_Operations）

ten1 = torch.tensor([1,2,3]) ten2 = torch.tensor([4,5,6]) ten1+ten2 

tensor([5, 7, 9])

你可以使用+或torch.add来执行张量添加。

torch.sub(ten2,ten1) 

tensor([3, 3, 3])

torch.add(ten1,ten2) 

tensor([5, 7, 9])

torch.subtract(ten2,ten1) 

tensor([3, 3, 3])

你可以使用- 或torch.sub来执行张量添加。

ten1*10 

tensor([10, 20, 30])

深度学习中非常重要的操作--矩阵乘法

Rules of Matrix Multiplication:

• (3,2) * (3,2) = Error
• (4,3) * (3,2) = (4,2)
• (2,2) * (2,5) = (2,5)

torch.matmul(ten1,ten2) 

tensor(32)

matrix4_3 = torch.tensor([[1,2,3],                         [4,5,6],                         [7,8,9],                         [10,11,12]]) 

matrix4_3.shape 

torch.Size([4, 3])

matrix3_2 = torch.tensor([[1,2],                         [3,4],                         [5,6]]) 

matrix3_2.shape 

torch.Size([3, 2])

result = torch.matmul(matrix4_3,matrix3_2) #=> will result in (4,2) 

result 

tensor([[ 22, 28],
[ 49, 64],
[ 76, 100],
[103, 136]])

result.shape 

torch.Size([4, 2])

你也可以使用torch.mm()，这是torch.matmul()的简称。

torch.mm(matrix4_3,matrix3_2) 

tensor([[ 22, 28],
[ 49, 64],
[ 76, 100],
[103, 136]])

#张量的转置 matrix4_3 

tensor([[ 1, 2, 3],
[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12]])

matrix4_3.T 

tensor([[ 1, 4, 7, 10],
[ 2, 5, 8, 11],
[ 3, 6, 9, 12]])

torch.t(matrix4_3) 

tensor([[ 1, 4, 7, 10],
[ 2, 5, 8, 11],
[ 3, 6, 9, 12]])

更多张量操作

• Zeros
• Ones
• Random
• Full

tensorZeroes = torch.zeros((3,3)) tensorZeroes 

tensor([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])

tensorOnes = torch.ones((3,3)) tensorOnes 

tensor([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])

tensorRandomN = torch.randn((3,3))  #includes negative tensors tensorRandomN 

tensor([[ 1.3255, -0.4937, 1.0488],
[ 1.1797, -0.5422, -0.9703],
[-0.1761, 1.0742, 0.5459]])

tensorRandom = torch.rand((3,3))  #includes only positive tensors tensorRandom 

tensor([[0.2013, 0.9272, 0.7866],
[0.5887, 0.9900, 0.3554],
[0.6128, 0.3316, 0.6635]])

customFill = torch.full((3,3),5) customFill 

tensor([[5, 5, 5],
[5, 5, 5],
[5, 5, 5]])

initialFill = torch.full((3,3),0.01) initialFill 

tensor([[0.0100, 0.0100, 0.0100],
[0.0100, 0.0100, 0.0100],
[0.0100, 0.0100, 0.0100]])

快速入门Torchvision

安装Torchvision，Torchvision软件包,包括流行的数据集、模型架构和计算机视觉的常见图像转换。

!pip install torchvision --no-deps -i https://pypi.tuna.tsinghua.edu.cn/simple 

from torch.utils.data import DataLoader from torchvision import datasets from torchvision.transforms import ToTensor from torch import nn 

# 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(), ) 

type(training_data) 

torchvision.datasets.mnist.FashionMNIST

Dataloader在我们的数据集上包裹了一个迭代器，并支持自动批处理、采样、洗牌和多进程数据加载。这里我们定义了一个64的批处理量，即dataloader可迭代的每个元素将返回64个特征和标签的批次。

import matplotlib.pyplot as plt  plt.figure(figsize=(12,10)) for i in range(9):     plt.subplot(3,3,i+1)     sample_image,sample_label = training_data[i]     plt.imshow(sample_image[0])     plt.title(sample_label) 

​

batch_size = 64  training = DataLoader(training_data,batch_size=batch_size) testing = DataLoader(test_data, batch_size=batch_size)  for X, y in testing:     print(f"Shape of X: {X.shape}")     print(f"Shape of y: {y.shape}")     break 

Shape of X: torch.Size([64, 1, 28, 28])
Shape of y: torch.Size([64])

for X,y in training:     print(torch.max(X))     print(torch.min(X))     break 

tensor(1.)
tensor(0.)

我们不需要扩展，因为 DataLoader会处理这个问题。

class NeuralNetwork(nn.Module):     def __init__(self):         super(NeuralNetwork,self).__init__()         self.flatten = nn.Flatten()         self.build_model = nn.Sequential(             nn.Linear(28*28,512), #28*28 is input shape             nn.ReLU(),             nn.Linear(512,512), #hidden layer             nn.ReLU(),             nn.Linear(512,10) #output layer         )     def forward(self,x):         x = self.flatten(x)         dnn = self.build_model(x)         return dnn  

model = NeuralNetwork() 

# compile model - Loss Function and Optimizer loss_fn = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=1e-5) 

def train(dataloader, model, loss_fn, optimizer):     size = len(dataloader.dataset)     model.train()     for batch, (X, y) in enumerate(dataloader):         # Compute prediction error         pred = model(X)         loss = loss_fn(pred, y)          # Backpropagation         optimizer.zero_grad()         loss.backward()         optimizer.step()          if batch % 100 == 0:             loss, current = loss.item(), batch * len(X)             print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]") 

def test(dataloader, model, loss_fn):     size = len(dataloader.dataset)     num_batches = len(dataloader)     model.eval()     test_loss, correct = 0, 0     with torch.no_grad():         for X, y in dataloader:             pred = model(X)             test_loss += loss_fn(pred, y).item()             correct += (pred.argmax(1) == y).type(torch.float).sum().item()     test_loss /= num_batches     correct /= size     print(f"Test Error: n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} n") 

for epoch in range(5):     print(f"Epochs {epoch+1}")     train(training, model, loss_fn, optimizer)     test(testing, model, loss_fn) print("Done!") 

Epochs 1
loss: 0.473322 [ 0/60000]
loss: 0.569312 [ 6400/60000]
loss: 0.383823 [12800/60000]
loss: 0.613123 [19200/60000]
loss: 0.511312 [25600/60000]
loss: 0.534981 [32000/60000]
loss: 0.519904 [38400/60000]
loss: 0.663009 [44800/60000]
loss: 0.595559 [51200/60000]
loss: 0.510713 [57600/60000]
Test Error:
Accuracy: 81.6%, Avg loss: 0.523760

Epochs 2
loss: 0.441475 [ 0/60000]
loss: 0.541651 [ 6400/60000]
loss: 0.362368 [12800/60000]
loss: 0.587903 [19200/60000]
loss: 0.489257 [25600/60000]
loss: 0.512706 [32000/60000]
loss: 0.496316 [38400/60000]
loss: 0.658995 [44800/60000]
loss: 0.588307 [51200/60000]
loss: 0.486178 [57600/60000]
Test Error:
Accuracy: 82.2%, Avg loss: 0.507999

Epochs 3
loss: 0.414868 [ 0/60000]
loss: 0.520754 [ 6400/60000]
loss: 0.345219 [12800/60000]
loss: 0.567657 [19200/60000]
loss: 0.470389 [25600/60000]
loss: 0.493463 [32000/60000]
loss: 0.477664 [38400/60000]
loss: 0.654533 [44800/60000]
loss: 0.580627 [51200/60000]
loss: 0.466487 [57600/60000]
Test Error:
Accuracy: 82.7%, Avg loss: 0.495437

Epochs 4
loss: 0.391931 [ 0/60000]
loss: 0.504477 [ 6400/60000]
loss: 0.331017 [12800/60000]
loss: 0.550430 [19200/60000]
loss: 0.453982 [25600/60000]
loss: 0.477417 [32000/60000]
loss: 0.462027 [38400/60000]
loss: 0.649069 [44800/60000]
loss: 0.573334 [51200/60000]
loss: 0.450685 [57600/60000]
Test Error:
Accuracy: 83.0%, Avg loss: 0.485073

Epochs 5
loss: 0.372204 [ 0/60000]
loss: 0.491510 [ 6400/60000]
loss: 0.318891 [12800/60000]
loss: 0.536430 [19200/60000]
loss: 0.440059 [25600/60000]
loss: 0.463519 [32000/60000]
loss: 0.449640 [38400/60000]
loss: 0.642708 [44800/60000]
loss: 0.565997 [51200/60000]
loss: 0.438368 [57600/60000]
Test Error:
Accuracy: 83.2%, Avg loss: 0.476352

Done!

我们将在下一个笔记本序列中探讨更多关于神经网络的问题。

Notebook:了解PytorchGet Started with PyTorch | Kaggle

原文作者：孤飞-博客园

我的个人博客：https://blog.onefly.top