pytorch 손실 값

Question

는 I는이 문서에 기초하여 모듈을 작성 변하지. TextClassifyCnnNet >>FlatCnnLayer >>FilterLayer

FilterLayer :

class FilterLayer(nn.Module): 
    def __init__(self, filter_size, embedding_size, sequence_length, out_channels=128): 
     super(FilterLayer, self).__init__() 

     self.model = nn.Sequential(
      nn.Conv2d(1, out_channels, (filter_size, embedding_size)), 
      nn.ReLU(inplace=True), 
      nn.MaxPool2d((sequence_length - filter_size + 1, 1), stride=1) 
     ) 

     for m in self.modules(): 
      if isinstance(m, nn.Conv2d): 
       n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels 
       m.weight.data.normal_(0, math.sqrt(2./n)) 

    def forward(self, x): 
     return self.model(x) 

FlatCnnLayer :

class FlatCnnLayer(nn.Module): 
    def __init__(self, embedding_size, sequence_length, filter_sizes=[3, 4, 5], out_channels=128): 
     super(FlatCnnLayer, self).__init__() 

     self.filter_layers = nn.ModuleList(
      [FilterLayer(filter_size, embedding_size, sequence_length, out_channels=out_channels) for 
      filter_size in filter_sizes]) 

    def forward(self, x): 
     pools = [] 
     for filter_layer in self.filter_layers: 
      out_filter = filter_layer(x) 
      # reshape from (batch_size, out_channels, h, w) to (batch_size, h, w, out_channels) 
      pools.append(out_filter.view(out_filter.size()[0], 1, 1, -1)) 
     x = torch.cat(pools, dim=3) 

     x = x.view(x.size()[0], -1) 
     x = F.dropout(x, p=dropout_prob, training=True) 

     return x 

TextClassifyCnnNet (주 모듈) :

class TextClassifyCnnNet(nn.Module): 
    def __init__(self, embedding_size, sequence_length, num_classes, filter_sizes=[3, 4, 5], out_channels=128): 
     super(TextClassifyCnnNet, self).__init__() 

     self.flat_layer = FlatCnnLayer(embedding_size, sequence_length, filter_sizes=filter_sizes, 
             out_channels=out_channels) 

     self.model = nn.Sequential(
      self.flat_layer, 
      nn.Linear(out_channels * len(filter_sizes), num_classes) 
     ) 

    def forward(self, x): 
     x = self.model(x) 

     return x 


def fit(net, data, save_path): 
    if torch.cuda.is_available(): 
     net = net.cuda() 

    for param in list(net.parameters()): 
     print(type(param.data), param.size()) 

    optimizer = optim.Adam(net.parameters(), lr=0.01, weight_decay=0.1) 

    X_train, X_test = data['X_train'], data['X_test'] 
    Y_train, Y_test = data['Y_train'], data['Y_test'] 

    X_valid, Y_valid = data['X_valid'], data['Y_valid'] 

    n_batch = len(X_train) // batch_size 

    for epoch in range(1, n_epochs + 1): # loop over the dataset multiple times 
     net.train() 
     start = 0 
     end = batch_size 

     for batch_idx in range(1, n_batch + 1): 
      # get the inputs 
      x, y = X_train[start:end], Y_train[start:end] 
      start = end 
      end = start + batch_size 

      # zero the parameter gradients 
      optimizer.zero_grad() 

      # forward + backward + optimize 
      predicts = _get_predict(net, x) 
      loss = _get_loss(predicts, y) 
      loss.backward() 
      optimizer.step() 

      if batch_idx % display_step == 0: 
       print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
        epoch, batch_idx * len(x), len(X_train), 100. * batch_idx/(n_batch + 1), loss.data[0])) 

     # print statistics 
     if epoch % display_step == 0 or epoch == 1: 
      net.eval() 
      valid_predicts = _get_predict(net, X_valid) 
      valid_loss = _get_loss(valid_predicts, Y_valid) 
      valid_accuracy = _get_accuracy(valid_predicts, Y_valid) 
      print('\r[%d] loss: %.3f - accuracy: %.2f' % (epoch, valid_loss.data[0], valid_accuracy * 100)) 

    print('\rFinished Training\n') 

    net.eval() 

    test_predicts = _get_predict(net, X_test) 
    test_loss = _get_loss(test_predicts, Y_test).data[0] 
    test_accuracy = _get_accuracy(test_predicts, Y_test) 
    print('Test loss: %.3f - Test accuracy: %.2f' % (test_loss, test_accuracy * 100)) 

    torch.save(net.flat_layer.state_dict(), save_path) 


def _get_accuracy(predicts, labels): 
    predicts = torch.max(predicts, 1)[1].data[0] 
    return np.mean(predicts == labels) 


def _get_predict(net, x): 
    # wrap them in Variable 
    inputs = torch.from_numpy(x).float() 
    # convert to cuda tensors if cuda flag is true 
    if torch.cuda.is_available: 
     inputs = inputs.cuda() 
    inputs = Variable(inputs) 
    return net(inputs) 


def _get_loss(predicts, labels): 
    labels = torch.from_numpy(labels).long() 
    # convert to cuda tensors if cuda flag is true 
    if torch.cuda.is_available: 
     labels = labels.cuda() 
    labels = Variable(labels) 
    return F.cross_entropy(predicts, labels) 

나는 3 개 사용자 정의 모듈로 내 소스 코드를 구분

매개 변수가 다시 나타납니다. 각 시대마다 약간의 차이가 있지만 정확성은 모든 과정에 남아 있습니다. 동일한 구현과 Tensorflow의 동일한 매개 변수를 사용하면 올바르게 실행됩니다.

저는 Pytorch에 익숙하지 않습니다. 어쩌면 내 지시 사항이 잘못되었을 수도 있습니다. 알아 내도록 도와주세요. 고맙습니다!

P .: F.cross_entropy 대신 F.nll_loss + F.log_softmax을 사용하려고합니다. 이론적으로는 동일하게 반환해야하지만 실제로 다른 결과가 출력됩니다 (그러나 여전히 잘못된 손실 값입니다).

Answer 1

Adam Optimizer의 L2_loss가 loss 값을 변경하지 않음을 알게되었습니다 (다른 최적화 도구).

# optimizer = optim.Adam(net.parameters(), lr=0.01, weight_decay=0.1) 
optimizer = optim.Adam(model.parameters(), lr=0.001) 

=== UPDATE (자세한 세부 사항에 대한 답변을 위하세요!) ===

self.features = nn.Sequential(self.flat_layer) 
self.classifier = nn.Linear(out_channels * len(filter_sizes), num_classes) 

... 

optimizer = optim.Adam([ 
    {'params': model.features.parameters()}, 
    {'params': model.classifier.parameters(), 'weight_decay': 0.1} 
], lr=0.001) 

Answer 2

나는 원래 코드에서 weight_decay 기간이 설정되어 있는지 보았다는 : 나는 L2_loss을 제거 할 때 그것은 작동 0.1이됩니다. weight_decay은 네트워크 매개 변수를 정규화하는 데 사용됩니다. 이 용어는 너무 강하기 때문에 정규화가 너무 어려울 수 있습니다. weight_decay 값을 줄이십시오.

컴퓨터 비전 작업의 길쌈 신경 네트워크의 경우. weight_decay 용어는 보통 5e-4 또는 5e-5으로 설정됩니다. 나는 텍스트 분류에 익숙하지 않다. 이 값은 상자에서 꺼내어도 작동 할 수도 있고 시행 착오에 의해 약간 조정해야 할 수도 있습니다.

작동하는지 알려주세요.