【Pytorch学习笔记】1.Pytoch概述

我就是我 2022-09-01 13:54 229阅读 0赞

### 文章目录 ###

*  0.课程大纲
 *  1.PyTorch介绍
 *  2.开发环境准备
 *  3.手写数字实战

根据龙良曲Pytorch学习视频整理，视频链接：  
[【计算机-AI】PyTorch学这个就够了！][-AI_PyTorch]  
[(好课推荐)深度学习与PyTorch入门实战——主讲人龙良曲][PyTorch]

# 0.课程大纲 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70]

# 1.PyTorch介绍 #

2017年1月，由Facebook人工智能研究院（FAIR）基于Torch推出了PyTorch。它是一个基于Python的可续计算包，提供两个高级功能：1、具有强大的GPU加速的张量计算（如NumPy）。2、包含自动求导系统的深度神经网络。

# 2.开发环境准备 #

cmd查看CUDA版本信息: `nvcc -V`  
![在这里插入图片描述][fd68947c0a494322bc7f879f90d8a2fb.png]  
cmd查看python版本信息：`python --version`  
![在这里插入图片描述][314a6ee0ed584306acb66b47312b42bb.png]  
python查看torch和cuda信息:

import torch
    
    print(torch.__version__)    # 1.9.0+cu102
    print('gpu:', torch.cuda.is_available())    # gpu: True

# 3.手写数字实战 #

numpy.genfromtxt()

file_name = "data.csv"
    """ 10.3,6.6 ... """
    # 从文本文件加载数据，并按指定处理缺失值
    points = numpy.genfromtxt(file_name, delimiter=",")
    for i in range(len(points)):
    	x = points[i, 0]
    	y = points[i, 1]

源码

import torch
    import matplotlib.pyplot as plt
    from torch import optim
    from torch import nn
    from torch.nn import functional as F
    from torchvision import datasets, transforms
    
    def plot_curve(data):
        fig = plt.figure()
        plt.plot(range(len(data)), data, color='blue')
        plt.legend(['value'], loc='upper right')
        plt.xlabel('step')
        plt.ylabel('value')
        plt.show()
    
    def plot_image(img, label, name):
        fig = plt.figure()
        for i in range(6):
            plt.subplot(2, 3, i+1)
            plt.tight_layout()
            plt.imshow(img[i][0]*0.0381+0.1307, cmap='gray', interpolation='none')
            plt.title("{}: {}".format(name, label[i].item()))
            plt.xticks([])
            plt.yticks([])
        plt.show()
    
    def one_hot(label, depth=10):
        out = torch.zeros(label.size(0), depth)
        idx = torch.LongTensor(label.view(-1, 1))
        out.scatter_(dim=1, index=idx, value=1)
        return out
    
    batch_size = 512
    
    # load dataset
    train_loader = torch.utils.data.DataLoader(
        datasets.MNIST('mnist_data', train=True,
                       transform=transforms.Compose([
                           transforms.ToTensor(),
                           transforms.Normalize((0.1307,), (0.3081,))
                       ])),
        batch_size=batch_size, shuffle=True
    )
    test_loader = torch.utils.data.DataLoader(
        datasets.MNIST('mnist_data/', train=False,
                       transform=transforms.Compose([
                           transforms.ToTensor(),
                           transforms.Normalize((0.1307,), (0.3081,))
                       ])),
        batch_size=batch_size, shuffle=True
    )
    
    x, y = next(iter(train_loader))
    print(x.shape, y.shape, x.min(), x.max())   # torch.Size([512, 1, 28, 28]) torch.Size([512]) tensor(-0.4242) tensor(2.8215)
    plot_image(x, y, 'image sample')
    
    
    class Net(nn.Module):
        def __init__(self):
            super(Net, self).__init__()
    
            # xw+b
            self.fc1 = nn.Linear(28*28, 256)
            self.fc2 = nn.Linear(256, 64)
            self.fc3 = nn.Linear(64, 10)
    
        def forward(self, x):
            # x: [b, 1, 28, 28]
            # h1 = relu(xw1+b1)
            x = F.relu(self.fc1(x))
            # h2 = relu(xw2+b2)
            x = F.relu(self.fc2(x))
            # h3 = relu(xw3+b3)
            x = self.fc3(x)
            return x
    
    net = Net()
    optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)
    
    train_loss = []
    
    for epoch in range(3):
        for batch_idx, (x, y) in enumerate(train_loader):
            # x: [b, 1, 28, 28], y:[512]
            # [b, 1, 28, 28] => [b, 784]
            x = x.view(x.size(0), 28*28)
            # => [b, 10]
            out = net(x)
            y_onehot = one_hot(y)
            loss = F.mse_loss(out, y_onehot)
    
            optimizer.zero_grad()   # 梯度清零
            loss.backward()         # 计算梯度
            optimizer.step()        # 更新梯度
    
            train_loss.append(loss.item())
    
            if batch_idx % 10 == 0:
                print(epoch, batch_idx, loss.item())
    
    plot_curve(train_loss)
    # we got optimal parameter
    
    total_correct = 0
    for x, y in test_loader:
        x = x.view(x.size(0), 28*28)
        out = net(x)
        pred = out.argmax(dim=1)
        correct = pred.eq(y).sum().float().item()
        total_correct += correct
    
    total_num = len(test_loader.dataset)
    acc = total_correct / total_num
    print('test acc.:', acc)    # test acc.: 0.8884
    
    x, y = next(iter(test_loader))
    out = net(x.view(x.size(0), 28*28))
    pred = out.argmax(dim=1)
    plot_image(x, pred, 'test')

运行结果  
**train loss**  
![train loss][]  
**predict image**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70 1]

[-AI_PyTorch]: https://www.bilibili.com/video/BV1Rv411y7oE?p=1
[PyTorch]: https://www.bilibili.com/video/BV1mh41167e3?p=1
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70]: /images/20220829/c3528502c1124e12b325c0c900dc6eeb.png
[fd68947c0a494322bc7f879f90d8a2fb.png]: /images/20220829/47f653d1146345a2a7f9547ce8aca883.png
[314a6ee0ed584306acb66b47312b42bb.png]: /images/20220829/2436124fb45c470a90f7f197bf536207.png
[train loss]: /images/20220829/7d6a351eaa1d4ca69fa7b91a4e885218.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70 1]: /images/20220829/a48160773bd641d0923d4d32c89e68cb.png