人工智能11-用Pytorch构建神经网络_torch设计神经网络-优快云博客

本文链接：https://blog.youkuaiyun.com/Kang_Kang330/article/details/140335234

pytorch

• Pytorch是torch的python版本，是由Facebook开源的神经网络框架，专门针对 GPU 加速的深度神经网络（DNN）编程。Torch 是一个经典的对多维矩阵数据进行操作的张量（tensor ）库，在机器学习和其他数学密集型应用有广泛应用。
Pytorch的计算图是动态的，可以根据计算需要实时改变计算图。

优势

简洁，速度，优雅易用，活跃的社区

常用工具包

torch ：类似 NumPy 的张量库，支持GPU；
torch.autograd ：基于 type 的自动区别库，支持 torch 之中的所有可区分张量运行；
torch.nn ：为最大化灵活性而设计，与 autograd 深度整合的神经网络库；
torch.optim：与 torch.nn 一起使用的优化包，包含 SGD、RMSProp、LBFGS、Adam 等标准优化方式；
torch.multiprocessing： python 多进程并发，进程之间 torch Tensors 的内存共享；
torch.utils：数据载入器。具有训练器和其他便利功能；
torch.legacy(.nn/.optim) ：出于向后兼容性考虑，从 Torch移植过来

通道问题

opencv的默认imread就是H* W* C，Pytorch的Tensor为C* H* W，TensorFlow两者都支持。

常用方法

torch.rand()函数用于生成具有均匀分布的随机数，这些随机数的范围在[0, 1)之间。它接受一个形状参数（shape），返回一个指定形状的张量（Tensor）
torch.randn()函数用于生成具有标准正态分布的随机数，即均值为0，标准差为1的随机数。它同样接受一个形状参数，并返回一个指定形状的张量。
torch.randint()函数用于生成指定范围内的整数随机数。它接受三个参数：low（最小值）、high（最大值）和形状（shape）。返回的张量中的元素值将在**[low, high)**范围内。
torch.randperm()函数用于生成一个从0到n-1的随机整数排列。它接受一个参数n，返回一个长度为n的张量，其中包含从0到n-1的随机整数，每个整数只出现一次。

import torch
'''@Time: 2024/7/11 21:20
全连接wx+b的过程
'''
class Linear(torch.nn.Module):
    def __init__(self, in_features, out_features, bias=True):
        super(Linear, self).__init__()
        self.weight = torch.nn.Parameter(torch.randn(out_features, in_features))
        if bias:
            self.bias = torch.nn.Parameter(torch.randn(out_features))

    def forward(self, x):
        x = x.mm(self.weight)
        if self.bias:
            x = x + self.bias.expand_as(x)
        return x

if __name__ == '__main__':
    # train for mnist
    net = Linear(3,2)
    x = net.forward
    print('11',x)

用torch构建网络的3中方法

方法1 定义一个model，add_module加层1，输入3，输出4；加层2，输入4，输出2；最后加一个输出层softmax-2.

model = nn.Sequential()
model.add_module(‘fc1’, nn.Linear(3,4))
model.add_module(‘fc2’, nn.Linear(4,2))
model.add_module(‘output’, nn.Softmax(2))

方法2 直接写到序列Sequential里

model2 = nn.Sequential(
nn.Conv2d(1,20,5),#输入1，输出20，kenal=5
nn.ReLU(),
nn.Conv2d(20,64,5),#输入20，输出64，kenal=5
nn.ReLU()
)

方法3 用ModuleList

model3 = nn.ModuleList([nn.Linear(3,4), nn.ReLU(), nn.Linear(4,2)])
‘’’
1、nn.Module 提供了神经网络的基类
2、需要训练的层写到init中，激活函数、softmax等写到forward中
‘’’

mnistnet代码

# -*- coding: utf-8 -*-
'''@Time: 2024/7/11 22:41

'''
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

class Model:
    def __init__(self, net, cost, optimist):
        self.net = net
        self.cost = self.create_cost(cost)
        self.optimizer = self.create_optimizer(optimist)
        pass

    def create_cost(self, cost):
        support_cost = {
            'CROSS_ENTROPY': nn.CrossEntropyLoss(),
            'MSE': nn.MSELoss()
        }

        return support_cost[cost]

    def create_optimizer(self, optimist, **rests):
        support_optim = {
            'SGD': optim.SGD(self.net.parameters(), lr=0.1, **rests),
            'ADAM': optim.Adam(self.net.parameters(), lr=0.01, **rests),
            'RMSP':optim.RMSprop(self.net.parameters(), lr=0.001, **rests)
        }

        return support_optim[optimist]

    def train(self, train_loader, epoches=3):
        for epoch in range(epoches):
            running_loss = 0.0
            for i, data in enumerate(train_loader, 0):
                inputs, labels = data

                self.optimizer.zero_grad()

                # forward + backward + optimize
                outputs = self.net(inputs)
                loss = self.cost(outputs, labels)
                loss.backward()
                self.optimizer.step()

                running_loss += loss.item()
                if i % 100 == 0:
                    print('[epoch %d, %.2f%%] loss: %.3f' %
                          (epoch + 1, (i + 1)*1./len(train_loader), running_loss / 100))
                    running_loss = 0.0

        print('Finished Training')

    def evaluate(self, test_loader):
        print('Evaluating ...')
        correct = 0
        total = 0
        with torch.no_grad():  #  # no grad when test and predict 表示with下面的所有数据不需要求导
            for data in test_loader:
                images, labels = data

                outputs = self.net(images)
                predicted = torch.argmax(outputs, 1)
                total += labels.size(0)
                correct += (predicted == labels).sum().item()

        print('Accuracy of the network on the test images: %d %%' % (100 * correct / total))

def mnist_load_data():
    transform = transforms.Compose(
        [transforms.ToTensor(),
         transforms.Normalize([0,], [1,])])

    trainset = torchvision.datasets.MNIST(root='./data', train=True,
                                            download=True, transform=transform)
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=32,
                                              shuffle=True, num_workers=2)

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


class MnistNet(torch.nn.Module):
    def __init__(self):
        super(MnistNet, self).__init__()
        self.fc1 = torch.nn.Linear(28*28, 512)
        self.fc2 = torch.nn.Linear(512, 512)
        self.fc3 = torch.nn.Linear(512, 10)

    def forward(self, x):
        x = x.view(-1, 28*28)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = F.softmax(self.fc3(x), dim=1)
        return x

if __name__ == '__main__':
    # train for mnist
    net = MnistNet()
    model = Model(net, 'CROSS_ENTROPY', 'RMSP')
    train_loader, test_loader = mnist_load_data()
    model.train(train_loader) #训练
    model.evaluate(test_loader)#推理过程（测试过程）
'''
1. 写好网络net ,model
2. 编写数据的标签和路径索引train_loader, test_loader
3. 把数据送到网络
'''