15、pytorch张量基本操作、卷积池化介绍、简单神经cnn网络搭建和训练示例_tensorflow和pytorch使用gpu训练cnn代码示例

第一章 pytorch介绍

PyTorch是一个基于Python的科学计算库，主要用于深度学习和人工神经网络。它是一个开源项目，由Facebook人工智能研究团队开发，并且非常受欢迎。PyTorch提供了一种灵活的、快速的、动态的计算图机制，使得构建和训练神经网络更具可读性和可维护性。PyTorch的核心功能包括：

1.动态计算图：PyTorch使用动态计算图机制，它允许使用Python的控制流和变量等语言特性，从而更高效地构建、debug和优化神经网络模型，而无需事先定义静态计算图。

2.自动微分：PyTorch提供了自动微分机制，可以方便地计算导数，从而支持训练神经网络。这使得在计算图中添加任意计算步骤时，能够自动计算模型参数的梯度。

3.灵活性： PyTorch 提供了一整套用于深度学习的工具集，包括卷积神经网络、循环神经网络、各种损失函数等，同时还提供了各种优化算法和内置的数据加载器等。

4.广泛的支持社区：PyTorch拥有一个庞大的社区支持，该社区为用户提供了丰富的教程、资源和支持，几乎覆盖了所有可能的深度学习应用和相关领域。PyTorch是一个基于Python的科学计算库，主要用于深度学习和人工神经网络。它是一个开源项目，由Facebook人工智能研究团队开发，并且非常受欢迎。PyTorch提供了一种灵活的、快速的、动态的计算图机制，使得构建和训练神经网络更具可读性和可维护性。PyTorch的核心功能包括：

第二章 pytorch中张量的数据类型介绍

PyTorch中的张量可以是许多不同的数据类型，包括整数（如int8、int16、int32、int64）、浮点数（如float16、float32、float64）、布尔值（bool）和复数等。不同类型的张量在存储和计算时具有不同的精度和内存占用。例如，float32的张量需要占用更多的内存空间，但具有较高的精度。而float16的张量占用更少的内存，但精度较低。在使用PyTorch时，需要根据具体的任务和需求选择适当的张量类型。可以使用.dtype属性获取或设置张量的数据类型。例如，使用以下语句可以创建一个浮点数张量：

import torch

# 创建一个2x3的浮点型张量
x = torch.FloatTensor([[1, 2, 3], [4, 5, 6]])
print(x.dtype) # 输出：torch.float32
 
1
2
3
4
5
6

import torch

# 创建一个2x3的浮点型张量
x = torch.FloatTensor([[1, 2, 3], [4, 5, 6]])
print(x.dtype) # 输出：torch.float32
 
1
2
3
4
5
6

import torch

# 创建一个2x3的浮点型张量
x = torch.FloatTensor([[1, 2, 3], [4, 5, 6]])
print(x.dtype) # 输出：torch.float32
 
1
2
3
4
5
6

第三章 pytorch张量的基本操作

PyTorch中的张量是一个多维数组，可以表示向量、矩阵、甚至是高维张量。以下是PyTorch中一些常用的张量操作：

3.1 创建张量

我们可以使用torch.Tensor()来创建一个张量。例如：

import torch

# 创建一个3x2的随机张量
a = torch.Tensor(3, 2)
print(a)
1
2
3
4
5

输出：

tensor([[ 0.0000e+00,  0.0000e+00],
        [-4.6566e-10,  0.0000e+00],
        [ 3.5873e-43,  0.0000e+00]])
1
2
3

还可以使用其他创建张量的方法，例如：

• torch.zeros()：创建全0张量
• torch.ones()：创建全1张量
• torch.rand()：创建随机张量

3.2 张量操作

张量支持很多操作，例如：

• torch.add()：对两个张量进行按元素相加操作
• torch.sub()：对两个张量进行按元素相减操作
• torch.mm()：矩阵乘法
• torch.matmul()：矩阵乘法，支持广播操作
• torch.transpose()：转置矩阵
• torch.narrow()：选择一段指定尺寸的区间，返回一个新的张量

还可以使用其他操作，例如torch.squeeze()、torch.unsqueeze()、torch.cat()等。

3.3 张量索引

张量可以通过索引来访问其元素。例如：

import torch

a = torch.randn(3, 4)
print(a[0])     # 访问第一行
print(a[:, 0])  # 访问第一列
print(a[1, 2])  # 访问(1, 2)位置的元素
1
2
3
4
5
6

3.4. 自动求导

PyTorch的一个很重要的功能就是自动求导。我们可以使用torch.autograd.Variable创建一个变量，然后对该变量进行操作。例如：

import torch
from torch.autograd import Variable

# 创建变量
x = Variable(torch.randn(3, 4), requires_grad=True)
y = x * 2
z = y.sum()

# 计算梯度
z.backward()

print(x.grad)  # 计算x的梯度
1
2
3
4
5
6
7
8
9
10
11
12

第四章 PyTorch中卷积、池化、激活函数、全连接层介绍

PyTorch是一种深度学习框架，用于创建神经网络模型。以下是有关PyTorch中卷积、池化、激活函数、全连接层的介绍：

4.1 卷积层

卷积层是深度学习中最常用的一种层之一。卷积层的作用是提取数据的特征。卷积层将输入数据与一组卷积核进行卷积运算，从而得到一个特征图。

在PyTorch中，卷积层可以通过torch.nn.Conv2d()来实现。该函数接受以下参数：

• in_channels: 输入数据的通道数
• out_channels: 输出数据的通道数
• kernel_size: 卷积核大小
• stride: 步长
• padding: 边缘填充
• dilation: 扩张率

4.2 池化层

池化层是用于减小数据体积的一种层。池化层通常会在卷积层的后面进行操作。池化层的作用是减小输入数据在空间上的大小，从而减少计算量。

在PyTorch中，池化层可以通过torch.nn.MaxPool2d()和torch.nn.AvgPool2d()来实现。MaxPool2d()函数从输入数据的每个区域中提取最大值，而AvgPool2d()函数从输入数据的每个区域中计算平均值。

4.3 激活函数

激活函数用于将线性输出转换为非线性输出。在神经网络中，激活函数可以增加网络的表达能力。激活函数可以应用于任何层的输出，通常会在卷积层和全连接层后面使用。

在PyTorch中，激活函数可以通过torch.nn.ReLU()、torch.nn.Sigmoid()和torch.nn.Tanh()等函数来实现。ReLU()函数将负数值设为0，而其他值保持不变。Sigmoid()函数将所有值压缩到0和1之间。Tanh()函数将所有值压缩到-1和1之间。

4.4 全连接层

全连接层是深度学习中最常用的一种层之一。全连接层的作用是将特征图转换为分类或回归分数。全连接层在网络的最后一层通常会使用。

在PyTorch中，全连接层可以通过torch.nn.Linear()函数来实现。Linear()函数接受两个参数：输入特征数和输出特征数。

第五章 pytorch中CNN网络搭建和训练示例

好的，以下是一个简单的CNN网络的搭建以及训练代码示例：

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

# 定义CNN网络模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# 定义数据集的transform
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

# 加载训练集和测试集
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)

# 定义损失函数和优化器
net = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

# 训练网络
for epoch in range(2):  # 多次遍历数据集

    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # 获取输入
        inputs, labels = data

        # 梯度清零
        optimizer.zero_grad()

        # 正向传播、反向传播、优化
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # 打印统计信息
        running_loss += loss.item()
        if i % 2000 == 1999:    # 每2000个小批量数据打印一次统计信息
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')

# 保存模型
PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)
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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

在上述代码中：

• 使用torch.nn模块定义了一个简单的CNN网络，包含两个卷积层、两个池化层以及三个全连接层；
• 使用torchvision.transforms模块定义了一个数据集的transform，其中包含了将PIL图像转换为张量、归一化等操作；
• 使用torch.utils.data模块加载了CIFAR10数据集，并通过DataLoader构建了训练集和测试集的迭代器；
• 使用torch.nn模块定义了交叉熵损失函数和随机梯度下降（SGD）优化器；
• 使用for循环遍历了数据集，并在循环中进行了前向传播、反向传播、优化等操作，同时打印了统计信息；
• 最后使用torch.save保存了模型的参数。