Pytorch 프레임 워 크 mnist 핸드폰 라 이브 러 리 식별 실현(tensorflow 와 비교)

앞에서 말 했 듯 이 최근 에 학습 과정 에서 pytorch 프레임 워 크 를 사용 하여 간단하게 배 웠 고 간단 한 사례 를 써 서 pytorch 에서 네트워크 기반 을 식별 하 는 것 을 기록 했다.한 블 로 거들 이 쓴 tensor flow 의 식별 mnist 데이터 세트 에 대응 하여 pytorch 프레임 워 크 로 바 꾸 고 두 프레임 워 크 의 대체적인 차 이 를 상세 하 게 볼 수 있다.
Tensorflow 버 전 전재 출처(CSDN 블 로 거'토끼 팔 고 1024'):https://www.jb51.net/article/191157.htm
Pytorch 실전 mnist 필기 숫자 인식

#      
import torch
import torch.nn as nn#       
import torch.optim as optim#     
from torch.utils.data import DataLoader#         
from torchvision import datasets, transforms#    mnsit   

#     

train_set = datasets.MNIST('./data', train=True, download=True,transform = transforms.Compose([
         transforms.ToTensor(),
         transforms.Normalize((0.1037,), (0.3081,))
       ]))
test_set = datasets.MNIST('./data', train=False, download=True,transform = transforms.Compose([
         transforms.ToTensor(),
         transforms.Normalize((0.1037,), (0.3081,))
       ]))

#    （      tensorflow      ）

class Net(nn.Module):

  def __init__(self, num_classes=10):
    super(Net, self).__init__()
    self.features = nn.Sequential(
      nn.Conv2d(1, 32, kernel_size=5, stride=1, padding=2),
      nn.MaxPool2d(kernel_size=2,stride=2),
      nn.Conv2d(32, 64, kernel_size=5, stride=1, padding=2),
      nn.MaxPool2d(kernel_size=2,stride=2),

    )
    self.classifier = nn.Sequential(
      nn.Linear(3136, 7*7*64),
      nn.Linear(3136, num_classes),

    )

  def forward(self,x):
    x = self.features(x)
    x = torch.flatten(x, 1)
    x = self.classifier(x)

    return x
net=Net()
net.cuda()# GPU  

#    ，  adam       
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), 1e-2)

train_data = DataLoader(train_set, batch_size=128, shuffle=True)
test_data = DataLoader(test_set, batch_size=128, shuffle=False)


#    
for epoch in range(1):
  net.train() ##        train()，     eval()
  batch = 0

  for batch_images, batch_labels in train_data:

    average_loss = 0
    train_acc = 0

    ## pytorch0.4   Variable  tensor    ，         Variable  
    if torch.cuda.is_available():
      batch_images, batch_labels = batch_images.cuda(),batch_labels.cuda()

    #    
    out = net(batch_images)
    loss = criterion(out,batch_labels)


    average_loss = loss
    prediction = torch.max(out,1)[1]
    # print(prediction)

    train_correct = (prediction == batch_labels).sum()
    ##     train_correct   longtensor ，     float

    train_acc = (train_correct.float()) / 128

    optimizer.zero_grad() #      ，                
    loss.backward() #loss    
    optimizer.step() ##    

    batch+=1
    print("Epoch: %d/%d || batch:%d/%d average_loss: %.3f || train_acc: %.2f"
       %(epoch, 20, batch, float(int(50000/128)), average_loss, train_acc))

#          
net.eval() #          
for idx,(im1, label1) in enumerate(test_data):
  if torch.cuda.is_available():
    im, label = im1.cuda(),label1.cuda()
  out = net(im)
  loss = criterion(out, label)

  eval_loss = loss

  pred = torch.max(out,1)[1]
  num_correct = (pred == label).sum()
  acc = (num_correct.float())/ 128
  eval_acc = acc

  print('EVA_Batch:{}, Eval Loss: {:.6f}, Eval Acc: {:.6f}'
   .format(idx,eval_loss , eval_acc))

실행 결과:

Pytorch 프레임 워 크 가 mnist 필기 라 이브 러 리 인식(tensorflow 와 대비)을 실현 하 는 것 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 Pytorch 프레임 워 크 가 mnist 필기 라 이브 러 리 인식(tensorflow 와 대비)을 실현 하 는 내용 은 예전 의 글 을 검색 하거나 아래 의 관련 글 을 계속 찾 아 보 세 요.앞으로 도 많은 응원 부 탁 드 리 겠 습 니 다!