了解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

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]])

快速入门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