Pytorch 의 데이터 세트 구분&정규 화 방법

1.훈련 집&검증 집&테스트 집
트 레이 닝 세트:트 레이 닝 데이터
검증 집합:서로 다른 알고리즘(예 를 들 어 격자 검색 을 이용 하여 초 매개 변 수 를 조정 하 는 등)을 검증 하고 어떤 것 이 더 효과 적 인지 검증 합 니 다.
테스트 집합:분류 기의 성능 을 정확하게 평가 합 니 다.
정상 적 인 절차:집회 기록 의 모든 시간 스탬프 인 자 를 검증 하고 test 데 이 터 를 불 러 오기 전에 가장 좋 은 인 자 를 불 러 와 평가 합 니 다.예 를 들 어 6000 개의 epoch 를 훈련 한 후에 3520 번 째 epoch 의 vaidation 이 가장 잘 표현 되 고 테스트 할 때 3520 번 째 epoch 의 인 자 를 불 러 옵 니 다.

import  torch
import  torch.nn as nn
import  torch.nn.functional as F
import  torch.optim as optim
from    torchvision import datasets, transforms
#   
batch_size=200
learning_rate=0.01
epochs=10
#      
train_db = datasets.MNIST('../data', train=True, download=True,   #train=True        
                   transform=transforms.Compose([                 #transform       
                       transforms.ToTensor(),                     #  Tensor     
                       transforms.Normalize((0.1307,), (0.3081,)) #       (        )
                   ]))
#DataLoader           ，           。           。           
train_loader = torch.utils.data.DataLoader(train_db, batch_size=batch_size, shuffle=True)
#      
test_db = datasets.MNIST('../data', train=False,
                   transform=transforms.Compose([
                        transforms.ToTensor(),
                        transforms.Normalize((0.1307,), (0.3081,))
                   ]))
test_loader = torch.utils.data.DataLoader(test_db, batch_size=batch_size, shuffle=True)
#              
print('train:', len(train_db), 'test:', len(test_db))                              #train: 60000 test: 10000
train_db, val_db = torch.utils.data.random_split(train_db, [50000, 10000])
print('db1:', len(train_db), 'db2:', len(val_db))                                  #db1: 50000 db2: 10000
train_loader = torch.utils.data.DataLoader(train_db, batch_size=batch_size, shuffle=True)
val_loader = torch.utils.data.DataLoader(val_db, batch_size=batch_size, shuffle=True)
class MLP(nn.Module):
    def __init__(self):
        super(MLP, self).__init__()
        self.model = nn.Sequential(         #        ,
            nn.Linear(784, 200),
            nn.ReLU(inplace=True),
            nn.Linear(200, 200),
            nn.ReLU(inplace=True),
            nn.Linear(200, 10),
            nn.ReLU(inplace=True),
        )
    def forward(self, x):
        x = self.model(x)
        return x
net = MLP()
#  sgd   ,      、   ，net.parameters()              [[w1,b1,w2,b2,...]
optimizer = optim.SGD(net.parameters(), lr=learning_rate)
criteon = nn.CrossEntropyLoss()
for epoch in range(epochs):
    for batch_idx, (data, target) in enumerate(train_loader):
        data = data.view(-1, 28*28)          #          [   ,784]
        logits = net(data)                   #    
        loss = criteon(logits, target)       #nn.CrossEntropyLoss()  Softmax
        optimizer.zero_grad()                #      
        loss.backward()                      #        
        optimizer.step()                     #     
        if batch_idx % 100 == 0:             # 100 batch      
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                       100. * batch_idx / len(train_loader), loss.item()))
    #              
    val_loss = 0
    correct = 0
    for data, target in val_loader:
        data = data.view(-1, 28 * 28)
        logits = net(data)
        val_loss += criteon(logits, target).item()
        pred = logits.data.max(dim=1)[1]
        correct += pred.eq(target.data).sum()
    val_loss /= len(val_loader.dataset)
    print('
VAL set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)
'.format(
        val_loss, correct, len(val_loader.dataset),
        100. * correct / len(val_loader.dataset)))
#       
test_loss = 0
correct = 0                                         #correct          
for data, target in test_loader:
    data = data.view(-1, 28 * 28)
    logits = net(data)
    test_loss += criteon(logits, target).item()     #    criteon(logits, target)  ，  
    pred = logits.data.max(dim=1)[1]                #     pred=logits.argmax(dim=1)
    correct += pred.eq(target.data).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)))

2.정규 화
정규 화 는 의합 문 제 를 해결 할 수 있다.
2.1L2 범 수(더 자주 사용)
최적화 기 를 정의 할 때 weigth 설정decay,즉 L2 범 수 앞의λ매개 변수.

optimizer = torch.optim.SGD(net.parameters(), lr=learning_rate, weight_decay=0.01)

2.2L 1 범 수
Pytorch 는 다음 과 같이 직접 호출 할 수 있 는 방법 이 없습니다.

3.운동량(Momentum)
Adam 유 틸 리 티 에는 momentum 이 내장 되 어 있 으 며 SGD 는 수 동 으로 설정 해 야 합 니 다.

optimizer = torch.optim.SGD(model.parameters(), args=lr, momentum=args.momentum, weight_decay=args.weight_decay)

4.학 습 률 감소
torch.optim.lr_scheduler 에 서 는 다양한 epoch 수 를 바탕 으로 학습 율 을 조정 하 는 방법 을 제공 합 니 다.
4.1torch.optim.lr_scheduler.ReduceLRON Plateau:측정 기준 을 바탕 으로 학습 율 을 동태 적 으로 낮 춥 니 다.

torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=10, verbose=False, threshold=0.0001, threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-08)

훈련 과정 에서 optimizer 는 learning rate 를 scheduler 관리 에 맡 깁 니 다.지표(예 를 들 어 loss)의 연속 patience 횟수 가 개선 되 지 않 았 을 때 학습 율 을 낮 춰 야 합 니 다.factor 는 매번 하락 하 는 비율 입 니 다.
scheduler.step(loss_val)호출 할 때마다 loss 를 감청 합 니 다.val。

4.2torch.optim.lr_scheduler.StepLR:epoch 기반

torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma=0.1, last_epoch=-1)

epoch 가 지나 갈 때마다 stopsize 시 학습 율 은 모두 초기 학습 율 의 gamma 배로 변 한다.

5.조기 정지(오 버 피 팅 방지)
경험 치 기반.
6.Dropout 랜 덤 부활
각 층 을 옮 겨 다 니 며 신경 망 의 노드 확률 을 제거 하고 간소화 한 샘플 을 얻 을 수 있 습 니 다.

torch.nn.Dropout(p=dropout_prob) 

p 는 노드 수 를 삭제 하 는 비율 을 나타 낸다(Tip:tensorflow 에서 keepprob 는 노드 수 를 유지 하 는 비율 을 표시 합 니 다.헷 갈 리 지 마 세 요)

테스트 단 계 는 dropout 를 사용 할 필요 가 없 기 때문에 train 전에 net 을 실행 합 니 다.dropped.train()은 dropout 를 사용 하 는 것 과 같 습 니 다.테스트 전에 net 을 실행 합 니 다.dropped.eval()은 dropout 를 사용 하지 않 는 것 과 같 습 니 다.

이상 은 개인 적 인 경험 이 므 로 여러분 에 게 참고 가 되 기 를 바 랍 니 다.여러분 들 도 저 희 를 많이 응원 해 주시 기 바 랍 니 다.