Блог

Моя сеть обрабатывает каждый тензор 1 на 1, поэтому она сгенерирует пару ввода и вывода, передаст входные данные в сеть, получит выходные данные для этой единственной пары тензоров и сравнит их с выходными данными.

Примером пары тензоров может быть tensor в качестве входных данных: [10, 1] и выходных данных [12, 1] и т.д. Это без заполнения. Вот общий процесс генерации пар тензоров:

 Input Tensor:  torch.Size([6, 1])
Target Tensor:  torch.Size([7, 1])

Input Tensor:  torch.Size([8, 1])
Target Tensor:  torch.Size([10, 1])

Input Tensor:  torch.Size([8, 1])
Target Tensor:  torch.Size([10, 1])
  

Более глубокий взгляд на генерируемый тензор был бы таким:

 Input Tensor:  
tensor([[22],
        [ 7],
        [18],
        [ 5],
        [ 1]])

Target Tensor: 
tensor([[23],
        [ 8],
        [ 6],
        [19],
        [ 6],
        [ 5],
        [ 1]])
  

Что я хотел бы сделать сейчас, так это внедрить пакетную обработку в этот процесс. Поэтому вместо того, чтобы генерировать одну пару, а затем выполнять пересылку по этой паре, я хотел бы сгенерировать большую партию пар (32, 64 …) и передать это вместо этого.

Как бы я приступил к созданию входного пакета и выходного пакета? Я считаю, что это должно выглядеть примерно как [40, 32] или [40, 64]

Вот моя программа на данный момент.

 def trainIters(encoder, decoder, n_iters, print_every=1000, plot_every=100, learning_rate=0.001, batch_size=64):
  
    training_pairs = [tensorsFromPair(random.choice(pairs))
                      for i in range(n_iters)]
    criterion = nn.CrossEntropyLoss()#nn.NLLLoss()

    for iter in range(1, n_iters   1):
        

        training_pair = training_pairs[iter - 1]
        input_tensor = training_pair[0]
        target_tensor = training_pair[1]

        print("Input Tensor: ", input_tensor.shape)
        print("Target Tensor: ",target_tensor.shape)

        loss = train(input_tensor, target_tensor, encoder,
                     decoder, encoder_optimizer, decoder_optimizer, criterion)

  

 def train(input_tensor, target_tensor, encoder, decoder, encoder_optimizer, decoder_optimizer, criterion, max_length=MAX_LENGTH):
    encoder_hidden = encoder.initHidden()

    encoder_optimizer.zero_grad()
    decoder_optimizer.zero_grad()

    input_length = input_tensor.size(0)
    target_length = target_tensor.size(0)

    encoder_outputs = torch.zeros(max_length, encoder.hidden_size, device=device)

    loss = 0
    for ei in range(input_length):

        encoder_output, encoder_hidden = encoder(
            input_tensor[ei], encoder_hidden)
        encoder_outputs[ei] = encoder_output[0, 0]


    decoder_input = torch.tensor([[SOS_token]], device=device)

    decoder_hidden = encoder_hidden

    use_teacher_forcing = True if random.random() < teacher_forcing_ratio else False

    if use_teacher_forcing:
        # Teacher forcing: Feed the target as the next input
        for di in range(target_length):
            decoder_output, decoder_hidden, decoder_attention = decoder(
                decoder_input, decoder_hidden, encoder_outputs)
            #print(decoder_output, target_tensor[di])
            loss  = criterion(decoder_output, target_tensor[di])
            decoder_input = target_tensor[di]  # Teacher forcing

    else:
        # Without teacher forcing: use its own predictions as the next input
        for di in range(target_length):
            decoder_output, decoder_hidden, decoder_attention = decoder(
                decoder_input, decoder_hidden, encoder_outputs)
            topv, topi = decoder_output.topk(1)
            decoder_input = topi.squeeze().detach()  # detach from history as input

            loss  = criterion(decoder_output, target_tensor[di])
            if decoder_input.item() == EOS_token:
                break

    loss.backward()

    encoder_optimizer.step()
    decoder_optimizer.step()

    return loss.item()