PyTorch:Softmax 다 분류 실전 조작

다 중 분류 에서 자주 사용 하 는 방법 은 마지막 층 에 softmax 를 추가 하여 귀 일 화 하 는 것 이 고 값 이 가장 큰 차원 에 대응 하 는 위 치 는 이 견본 에 대응 하 는 유형 으로 한다.본 고 는 PyTorch 프레임 워 크 를 사용 하여 전형 적 인 이미지 데이터 세트 mnist 를 선택 하여 다 중 분 류 를 학습 합 니 다.
MNIST 데이터 세트
MNIST 데이터 세트(손 으로 쓴 디지털 데이터 세트)는 미국 국가 표준 과 기술 연구소,National Institute of Standards and Technology(NIST)에서 나 왔 다.훈련 집(training set)은 250 개의 서로 다른 손 으로 쓴 숫자 로 구성 되 어 있 으 며 이 중 50%는 고등 학생 이다.인구 센서 스 국(the Census Bureau)의 50%가 근무 하고 있 으 며,테스트 세트(test set)도 같은 비율의 필기 숫자 데이터 다.MNIST 데이터 세트 다운로드 주소:http://yann.lecun.com/exdb/mnist/。손 으로 쓴 숫자의 MNIST 데이터 베 이 스 는 60,000 개의 훈련 집 샘플 과 10,000 개의 테스트 집 샘플 을 포함한다.

그 중:
train-images-idx 3-ubyte.gz(훈련 데이터 세트 사진)
train-labels-idx1-ubyte.gz(훈련 데이터 세트 태그 유형)
t10k-images-idx3-ubyte.gz:(테스트 데이터 세트)
t10k-labels-idx1-ubyte.gz(테스트 데이터 세트 태그 클래스)

MNIST 데이터 세트 는 10 개의 카 테 고리(0 에서 9)를 포함 한 전형 적 인 이미지 데이터 세트 입 니 다.모든 그림 을 벡터 로 끌 어 당 기 는 것 은 다음 그림 784 차원 벡터 를 1 층 입력 특징 으로 한다.

Softmax 분류
softmax 함수 의 본질은 하나의 K 차원 의 임 의 실수 벡터 를 다른 K 차원 의 실수 벡터 로 압축 하 는 것 이다.그 중에서 벡터 중의 모든 요소 의 수 치 는(0,1)사이 에 있 고 압축 된 K 개의 수 치 는 1(확률 분포 로 변 함)과 같다.Softmax 를 선택 하여 다 중 분 류 를 할 때 값 의 크기 에 따라 다 중 분류 작업 을 할 수 있 습 니 다.예 를 들 어 가중치 가 가장 큰 1 차원 입 니 다.softmax 소개 와 공식 인터넷 이 많 습 니 다.여 기 는 소개 하지 않 겠 습 니 다.다음은 Pytorch 를 사용 하여 다 층 네트워크(4 개의 숨겨 진 층,마지막 층 softmax 확률 을 획일 화)를 정의 합 니 다.출력 층 은 10 가지 로 10 가지 에 대응 합 니 다.

PyTorch 실전

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.autograd import Variable

# Training settings
batch_size = 64

# MNIST Dataset
train_dataset = datasets.MNIST(root='./mnist_data/',
                train=True,
                transform=transforms.ToTensor(),
                download=True)

test_dataset = datasets.MNIST(root='./mnist_data/',
               train=False,
               transform=transforms.ToTensor())

# Data Loader (Input Pipeline)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                      batch_size=batch_size,
                      shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                     batch_size=batch_size,
                     shuffle=False)
class Net(nn.Module):
  def __init__(self):
    super(Net, self).__init__()
    self.l1 = nn.Linear(784, 520)
    self.l2 = nn.Linear(520, 320)
    self.l3 = nn.Linear(320, 240)
    self.l4 = nn.Linear(240, 120)
    self.l5 = nn.Linear(120, 10)

  def forward(self, x):
    # Flatten the data (n, 1, 28, 28) --> (n, 784)
    x = x.view(-1, 784)
    x = F.relu(self.l1(x))
    x = F.relu(self.l2(x))
    x = F.relu(self.l3(x))
    x = F.relu(self.l4(x))
    return F.log_softmax(self.l5(x), dim=1)
    #return self.l5(x)
model = Net()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
def train(epoch):

  #     barch_idx   
  for batch_idx, (data, target) in enumerate(train_loader):
    data, target = Variable(data), Variable(target)

    optimizer.zero_grad()
    output = model(data)
    # loss
    loss = F.nll_loss(output, target)
    loss.backward()
    # update
    optimizer.step()
    if batch_idx % 200 == 0:
      print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
        epoch, batch_idx * len(data), len(train_loader.dataset),
        100. * batch_idx / len(train_loader), loss.data[0]))
def test():
  test_loss = 0
  correct = 0
  #    
  for data, target in test_loader:
    data, target = Variable(data, volatile=True), Variable(target)
    output = model(data)
    # sum up batch loss
    test_loss += F.nll_loss(output, target).data[0]
    # get the index of the max
    pred = output.data.max(1, keepdim=True)[1]
    correct += pred.eq(target.data.view_as(pred)).cpu().sum()

  test_loss /= len(test_loader.dataset)
  print('
Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)
'.format(
    test_loss, correct, len(test_loader.dataset),
    100. * correct / len(test_loader.dataset)))

for epoch in range(1,6):
  train(epoch)
  test()

    ：
Train Epoch: 1 [0/60000 (0%)]	Loss: 2.292192
Train Epoch: 1 [12800/60000 (21%)]	Loss: 2.289466
Train Epoch: 1 [25600/60000 (43%)]	Loss: 2.294221
Train Epoch: 1 [38400/60000 (64%)]	Loss: 2.169656
Train Epoch: 1 [51200/60000 (85%)]	Loss: 1.561276

Test set: Average loss: 0.0163, Accuracy: 6698/10000 (67%)

Train Epoch: 2 [0/60000 (0%)]	Loss: 0.993218
Train Epoch: 2 [12800/60000 (21%)]	Loss: 0.859608
Train Epoch: 2 [25600/60000 (43%)]	Loss: 0.499748
Train Epoch: 2 [38400/60000 (64%)]	Loss: 0.422055
Train Epoch: 2 [51200/60000 (85%)]	Loss: 0.413933

Test set: Average loss: 0.0065, Accuracy: 8797/10000 (88%)

Train Epoch: 3 [0/60000 (0%)]	Loss: 0.465154
Train Epoch: 3 [12800/60000 (21%)]	Loss: 0.321842
Train Epoch: 3 [25600/60000 (43%)]	Loss: 0.187147
Train Epoch: 3 [38400/60000 (64%)]	Loss: 0.469552
Train Epoch: 3 [51200/60000 (85%)]	Loss: 0.270332

Test set: Average loss: 0.0045, Accuracy: 9137/10000 (91%)

Train Epoch: 4 [0/60000 (0%)]	Loss: 0.197497
Train Epoch: 4 [12800/60000 (21%)]	Loss: 0.234830
Train Epoch: 4 [25600/60000 (43%)]	Loss: 0.260302
Train Epoch: 4 [38400/60000 (64%)]	Loss: 0.219375
Train Epoch: 4 [51200/60000 (85%)]	Loss: 0.292754

Test set: Average loss: 0.0037, Accuracy: 9277/10000 (93%)

Train Epoch: 5 [0/60000 (0%)]	Loss: 0.183354
Train Epoch: 5 [12800/60000 (21%)]	Loss: 0.207930
Train Epoch: 5 [25600/60000 (43%)]	Loss: 0.138435
Train Epoch: 5 [38400/60000 (64%)]	Loss: 0.120214
Train Epoch: 5 [51200/60000 (85%)]	Loss: 0.266199

Test set: Average loss: 0.0026, Accuracy: 9506/10000 (95%)
Process finished with exit code 0

훈련 교체 횟수 가 증가 함 에 따라 테스트 집의 정확 도 는 여전히 매우 높 아 졌 다.또한 교체 횟수 가 5 일 때 이런 간단 한 네트워크 를 사용 하면 95%의 정확도 에 이 를 수 있다.
이상 의 PyTorch:Softmax 다 분류 실전 작업 은 바로 편집장 이 여러분 에 게 공유 한 모든 내용 입 니 다.여러분 에 게 참고 가 되 었 으 면 좋 겠 습 니 다.여러분 들 도 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.