搜索

Pytorch 学习笔记之入门

Pytorch 学习笔记(CPU only)之入门

如果想进一步了解神经网络的内部结构，建议不要使用这些深度学习框架，如果有能力和时间，建议采用numpy类库从底层实现一个神经网络各种操作，比如：前向传播、反向传播、梯度下降等。

1. 开始

1.1 构成

Pytorch 是由 Facebook 于 2016 年推出的一款深度学习框架。Pytorch 主要由以下包构成：

Packages Description
torch.nn A subpackage that contains modules and extensible classes for building neural networks.
(包含用于构建神经网络的模块和可扩展类的子包。)
torch.autograd A subpackage that supports all the differentiable Tensor operations in PyTorch.
torch.nn.functional A functional interface that contains typical operations used for building neural networks like loss functions, activation functions, and convolution operations.
(一个功能接口，其中包含用于构建神经网络的典型操作，例如损失函数，激活函数和卷积操作。)
torch.optim A subpackage that contains standard optimization operations like SGD and Adam.
(包含基本优化例如:随机梯度下降、Adam 等操作的子包。)
torch.utils A subpackage that contains utility classes like data sets and data loaders that make data preprocessing easier.
(包含数据集和数据加载器等实用工具类的子包，使数据预处理更容易。)
torchvision A package that provides access to popular datasets, model architectures, and image transformations for computer vision.
(包含可以访问流行的数据集，模型架构和计算机视觉图像转换的包)

1.2 Tensor

tensor（张量）是Pytorch中基本的数据结构。一维向量、二维矩阵、三维矩阵等都可以视为张量。

tensor 就是一个高维矩阵。

在Pytorch中封装了torch.Tensor这个类，创建的tensor都是这个类的实例。在torch中，有四种方式创建一个tensor。

1.torch.Tensor(data)

2.torch.tensor(data)(推荐)

3.torch.as_tensor(data)

4.torch.from_numpy(data)

传入的data可以是python中的array、list，或者numpy中的ndarray。 可以用 python 的索引和切片来获取和修改一个张量 tensor 中的内容。

tensor 的属性：

dtype：torch 中共有七种 CPU tensor 类型和八种 GPU tensor 类型。

Data type CPU tensor GPU tensor
32-bit floating point torch.FloatTensor torch.cuda.FloatTensor
64-bit floating point torch.DoubleTensor torch.cuda.DoubleTensor
16-bit floating point N/A torch.cuda.HalfTensor
8-bit integer (unsigned) torch.ByteTensor torch.cuda.ByteTensor
8-bit integer (signed) torch.CharTensor torch.cuda.CharTensor
16-bit integer (signed) torch.ShortTensor torch.cuda.ShortTensor
32-bit integer (signed) torch.IntTensor torch.cuda.IntTensor
64-bit integer (signed) torch.LongTensor torch.cuda.LongTensor

shape：返回tensor的维度，注：size()方法结果相同。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
data = np.array([1,2,3])
> type(data)
numpy.ndarray

> o1 = torch.Tensor(data)
> o2 = torch.tensor(data)
> o3 = torch.as_tensor(data)
> o4 = torch.from_numpy(data)

> print(o1)
> print(o2)
> print(o3)
> print(o4)
tensor([1., 2., 3.])
tensor([1, 2, 3], dtype=torch.int32)
tensor([1, 2, 3], dtype=torch.int32)
tensor([1, 2, 3], dtype=torch.int32)

> data2 = np.random.randint(1,10,(3,3))#创建一个大小为3*3,初始值为1-10之间的矩阵
> o5 = torch.tensor(data2)
> print(o5)
tensor([[5, 1, 9],
        [7, 3, 2],
        [3, 3, 1]], dtype=torch.int32)
> o5[0][1]
tensor(5, dtype=torch.int32)
> o5.shape
torch.Size([3, 3])
# 转为numpy数组
> o5.numpy()
array([[5, 1, 9],
       [7, 3, 2],
       [3, 3, 1]])

创建 tensor 的其他方式：

  1. torch.eye(n)：创建 n 阶的单位矩阵

  2. torch.zeros(n)： param可以是一个数字n，表示初始化为 1n 的向量；也可以是一个元组或列表(n,m)，表示`n m`的 0 矩阵。

  3. torch.ones(param)：

    1
    2
    3
    4
    5
    6
    7
    print(torch.ones([2,3]))
    #print(torch.ones(2,3)
    tensor([[0., 0., 0.],
            [0., 0., 0.]])

    print(torch.zeros(3))
    tensor([0., 0., 0., 0., 0.])

  4. troch.ones(param)：同上

  5. torch.rand(parma)：初始化为0-1之间的数。

  6. torch.randn(param)： 标准正态分布 之中的数。

1.3 tensor 的操作

  • numpy()：转为numpy.ndarray

  • eq()：用来比较两个tensor各个元素是否相等。

    1
    2
    3
    4
    5
    6
    > preds = torch.tensor([1,2,3,4])
    > labels = torch.tensor([1,5,4,4])
    > preds.eq(labels)
    tensor([ True, False, False,  True])
    > preds.eq(labels).sum().item()
    2

  • reshape()：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    > t = torch.tensor([
        [1,1,1,1],
        [2,2,2,2],
        [3,3,3,3]
    ])
    > t.size()
    torch.Size([3, 4])

    > t.shape
    torch.Size([3, 4])

    > t.reshape([1,12])
    tensor([[1., 1., 1., 1., 2., 2., 2., 2., 3., 3., 3., 3.]]) #二维的

    > t.reshape(-1)
    tensor([1., 1., 1., 1., 2., 2., 2., 2., 3., 3., 3., 3.])  #一维的

    > t.reshape(6,2)
    tensor([[1., 1.],
            [1., 1.],
            [2., 2.],
            [2., 2.],
            [3., 3.],
            [3., 3.]])

    #升维
    > t.reshape(2,2,3)
    tensor(
    [
        [
            [1., 1., 1.],
            [1., 2., 2.]
        ],

        [
            [2., 2., 3.],
            [3., 3., 3.]
        ]
    ])

    注意：reshape 返回后的结果可能与原tensor共享数据，而维度不同，即：你改变了 reshape 后的数据，原数据也会被修改；又或者 reshape 后的不共享存储。（无语….）

  • squeeze() 将所有为 1 的维度删掉，可以传入具体的参数，表示将第几个维度进行“挤压”，如果指定维度不为1，那么调用该方法tensor不发生改变。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
      > t1 = torch.tensor([[1],[2],[3],[4]]) # [4,1]
      > t1_ = t1.squeeze(-1)# t1.squeeze(1)
      tensor([1, 2, 3, 4])#[4]
      > t1_.shape
      torch.Size([4])

      > a = torch.randn(1,1,3)
      > print(a)
      tensor([[[ 1.8239, -1.0579,  0.3052]]])

      > b = torch.squeeze(a) # 将a中所有为1的维度删掉。不为1的维度没有影响。
      > b
      tensor([ 1.8239, -1.0579,  0.3052])
    #[3]
      > c=torch.squeeze(a,1) # 第2维度是否为1，为1就删掉，成为2维矩阵；不为1则不受影响
      > c
      tensor([[ 0.6552,  0.9220, -0.9763]])

  • unsqueeze() 对给指定位置加上维数为一的维度

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    > a = torch.linspace(-1, 1, 100)
    > a,shape
    torch.Size([100])

    > b = a.unsqueeze(0)
    > b.shape
    torch.Size([1,100])

    > c = a.unsqueeze(1)
    > c.shape
    torch.Size([100,1])

  • flatten就是reshape和squeezee二者结合。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    def flatten(t):
        t = t.reshape(1, -1)
        t = t.squeeze()
        return t
    > t = torch.ones(4,3)
    > flatten(t) # t.reshape(1,-1).squeezee()
    tensor([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])
    >  t.flatten()
    tensor([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

  • cat()两个矩阵的拼接，按照行/列进行拼接。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    >>> t1 = torch.tensor([[1,2,3,4],[5,6,7,8]]) # 2*4
    >>> t2 = torch.tensor([[4],[8]]) # 2*1
    >>> torch.concat((t1,t2),dim = 1) #t2列数与t1不同，只能横着拼接，依旧是行方向
    tensor([[1, 2, 3, 4, 4],
            [5, 6, 7, 8, 8]])
    >>> t3 = torch.tensor([[9,2,3,4]]) # [9,2,3,4]会报错！维度不一样 [4] [[9,2,3,4]] => [1,4]
    tensor([[1, 2, 3, 4],
            [5, 6, 7, 8],
            [9, 2, 3, 4]])

  • stack() 要求输入的两个张量维度完全相同，结果比原张量维度+1

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    >>> t1 = torch.tensor([[1,2],[3,4]])
    >>> t2 = torch.tensor([[5,6],[7,8]])
    >>> torch.stack((t1,t2))
    tensor([[[1, 2],
             [3, 4]],

            [[5, 6],
             [7, 8]]])
    >>> res = torch.stack((t1,t2),1)
    >>> res
    tensor([[[1, 2],
             [5, 6]],

            [[3, 4],
             [7, 8]]])
    >>> res.shape
    torch.Size([2, 2, 2])

    tips：在图像数据集中，data的维度通常是四维的。每个维度分别代表：[batch,channel,width,height]*

  • view()：用来改变tensor的维度。类似于reshape()。 如果是torch.view(-1)，则原张量会变成一维的结构（和flatten操作相同） 。

    注意：view()操作会与原tensor共享数据！！！

  • permute：交换维度

    1
    2
    3
    4
    > t = torch.randn(5,2,3)
    > t = t.permute(1,2,0)
    > t.shape
    [3,2,5]
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
      
    * `type_as`：转换`tensor`类型，`tensor`默认小数为`float`型。

      ```pyth
      > t1 = np.linspace(-10,10,100)
      > t1_ = torch.tensor(t1)
      > t1_.dtype
      torch.float64

      t1_ = t1_.type_as(torch.FloatTensor())
      > t1_.dtype
      torch.float32

1.4 tensor 的广播以及 reduction 操作

和numpy类似，tensor 也可以进行每一列/行求均值(mean)、max、argmax、sum、std等操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
> t = torch.tensor([
    [0,1,0],
    [2,0,2],
    [0,3,0]
], dtype=torch.float32)
> t.sum()
tensor(8.)
> t.numel()
9

> t.sum().numel()
1
> t.prod()
tensor(0.)
> t.mean() #求所有数值的均值
tensor(.8889)

> t.mean(axis=1) #求每一行的均值
tensor([0.3333, 1.3333, 1.0000])

> t.argmax(axis=0) #求每一列最大值的索引
tensor([1, 2, 1])

> t.mean().item() #将得到的tensor最终转为数值，只包含一个元素的tensor才可以有这个操作
8.0

> t.argmax(dim = 0).tolist()
[1,2,1]

1.5 数据集的加载

通常数据要经过以下处理：

  • Extract data from a data source.
  • Transform data into a desirable format.
  • Load data into a suitable structure.

加载自定义数据集通常使用torch.utils.data下的Dataset,DataLoader。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
from torch.utils.data import Dataset,DataLoader

class FakeDataSet(Dataset):
    def __init__(self,data):
        self.data = data
        
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self,idx):
        return self.data[idx]

data = np.random.rand(100,10)
dataset = FakeDataSet(data)
dataloader = DataLoader(dataset,batch_size=10,shuffle=True)

for batch in enumerate(dataloader):
    # batch是一个元组，第一个元素表示索引，第二个元素表示真正的数据
    print(batch[1].shape)
# Outputs 一共10个batch
torch.Size([10, 10])
torch.Size([10, 10])
torch.Size([10, 10])
torch.Size([10, 10])
torch.Size([10, 10])
torch.Size([10, 10])
torch.Size([10, 10])
torch.Size([10, 10])
torch.Size([10, 10])
torch.Size([10, 10])

1.6 自动求梯度

定义了一个损失函数后，通过backward方法就可以自动求变量的梯度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def f(x):
    return (x-2)**2 + 2*x 

def fp(x):
    return 2*(x-2) + 2

x = torch.tensor([2.0],requires_grad=True)

y = f(x)

y.backward()

x.grad
# Outputs
tensor([2.])

fp(x)
# Outputs
tensor([2.], grad_fn=<AddBackward0>)

1.7 实现一个线性回归

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F

import torchvision
import torchvision.transforms as transforms

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

#定义模型
class LinearRegression(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(in_features=1,out_features=1,bias=True)
    def forward(self,x):
        x = x
        out = self.linear(x)
        return out

x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)
y = 3*x + 5 + torch.rand(x.size())

model = LinearRegression()
# 选定loss函数
loss = nn.MSELoss()
# 定义优化函数 ，绑定模型参数
optimizer = torch.optim.SGD(model.parameters(), lr=1e-2)
# 开始训练
for epoch in range(1000):
    out = model(x)
    ls = loss(out,y)
    # 清空梯度。否则会累计
    optimizer.zero_grad()
    # 求梯度
    ls.backward()
    # 优化器反向传播更新参数
    optimizer.step()

    print("loss:" + str(ls.item()))
#检验模型
preds = model(x)
plt.plot(x.numpy(), y.numpy(), 'ro', label='Original Data')
plt.plot(x.numpy(), preds.data.numpy(), label='Fitting Line')

print(model.linear.weight,model.linear.bias)
输出如下:
Parameter containing:
tensor([[3.0281]], requires_grad=True)
Parameter containing:
tensor([5.4789], requires_grad=True)

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true