pytorch是什么_pytorch转onnx?

import numpy as np
import torch
from torch import nn,optim
from torch.autograd import Variable
from  torchvision import datasets,transforms
from torch.utils.data import DataLoader

#加载训练集
train_dataset = datasets.MNIST(root='./',
                               train=True,
                               transform=transforms.ToTensor(),
                               download=True)


#加载测试集
test_dataset = datasets.MNIST(root='./',
                              train=False,
                              transform=transforms.ToTensor(),
                              download=True)


#批次大小
batch_size = 64

#装载训练集
train_loader = DataLoader(dataset = train_dataset,
                          batch_size=batch_size,
                          shuffle=True)

test_loader = DataLoader(dataset = test_dataset,
                          batch_size=batch_size,
                          shuffle=True)

for i,data in enumerate(train_loader):
    inputs,labels = data
    print(inputs.shape)
    print(labels.shape)
    break

print("labels>>>",labels)
print("len(train_loader)>>>>",len(train_loader))

#定义网络结构
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(784,10)
        self.softmax = nn.Softmax(dim=1)


    def forward(self,x):
        x = x.view(x.size()[0], -1)
        x = self.fc1(x)
        x = self.softmax(x)
        return x


LR = 0.5
#定义模型
model = Net()
#定义 代价函数
mse_loss = nn.MSELoss()
#定义优化器
optimizer = optim.SGD(model.parameters(),LR)

def train():
    for i,data in enumerate(train_loader):
        #获得一个批次的数据和标签
        inputs, lables = data
        #获得模型预测结果(64,10)
        out = model(inputs)
        #to onehot，把数据标签变成独热编码
        #（64）->(64,1)
        lables = lables.reshape(-1,1)

        #tensor.scatter(dim,index,src)
        #dim:对哪个维度进行独热编码
        #index:要将src中对应的值放到tensor的哪个位置。
        #src:插入index的数值

        one_hot = torch.zeros(inputs.shape[0],10).scatter(1,lables,1)
        #计算loss,mes_loss的两个数据的shape要一致
        loss = mse_loss(out,one_hot)
        #梯度清0
        optimizer.zero_grad()
        #计算梯度
        loss.backward()
        #修改权值
        optimizer.step()

def test():
    correct = 0
    for i,data in enumerate(test_loader):
        #获得一个批次的数据和标签
        inputs,labels = data
        #获得模型预测结果（64，10）
        out = model(inputs)
        #获得最大值，以及最大值所在的位置
        _,predicted = torch.max(out,1)
        correct += (predicted == labels).sum()

        print("Test acc:{0}".format(correct.item() / len(test_dataset)))


for epoch in range(10):
    print('epoch:',epoch)
    train()
    test()



输出的结果
torch.Size([64, 1, 28, 28])
torch.Size([64])
labels>>> tensor([7, 5, 8, 1, 9, 7, 4, 4, 3, 3, 9, 1, 4, 5, 6, 6, 9, 3, 6, 5, 6, 4, 0, 7,
        0, 2, 7, 4, 6, 6, 0, 2, 5, 6, 4, 2, 4, 6, 6, 1, 4, 4, 6, 2, 8, 4, 9, 9,
        3, 3, 1, 6, 3, 4, 1, 4, 1, 8, 2, 7, 4, 5, 6, 3])
len(train_loader)>>>> 938
epoch: 0
Test acc:0.8887
epoch: 1
Test acc:0.9004
epoch: 2
Test acc:0.9072
epoch: 3
Test acc:0.9118
epoch: 4
Test acc:0.9145
epoch: 5
Test acc:0.9164
epoch: 6
Test acc:0.9175
epoch: 7
Test acc:0.9185
epoch: 8
Test acc:0.9189
epoch: 9
Test acc:0.9201

Process finished with exit code 0