def evaluate(input, max_length=MAX_LENGTH):
#print(input)
with torch.no_grad():
input_tensor = torch.tensor(input)
input_length = input_tensor.size()[0]
encoder_hidden = encoder.initHidden()
encoder_outputs = torch.zeros(max_length, encoder.hidden_size, device=device)
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([[getStartIndex()]], device=device) # SOS
decoder_hidden = encoder_hidden
decoded_words = []
decoder_attentions = torch.zeros(max_length, max_length)
for di in range(max_length):
decoder_output, decoder_hidden, decoder_attention = decoder(decoder_input, decoder_hidden, encoder_outputs)
decoder_attentions[di] = decoder_attention.data
topv, topi = decoder_output.data.topk(1)
if topi.item() == getStopIndex():
decoded_words.append(getStopIndex())
break
else:
decoded_words.append(topi.item())
decoder_input = topi.squeeze().detach()
return decoded_words, decoder_attentions[:di + 1]
def train(input, target, encoder, decoder, encoder_optimizer,
decoder_optimizer, criterion, max_length):
encoder_hidden = encoder.initHidden()
encoder_optimizer.zero_grad()
decoder_optimizer.zero_grad()
input_length = len(input)
target_length = len(target)
input = torch.tensor(input)
target = torch.tensor(target).view(-1, 1)
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[ei], encoder_hidden)
encoder_outputs[ei] = encoder_output[0, 0]
decoder_input = torch.tensor([[getStartIndex()]], 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)
loss += criterion(decoder_output, target[di])
decoder_input = target[di] # Teacher forcing
else:
#raise NotImplementedError
# 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[di])
if decoder_input.item() == getStopIndex():
break
loss.backward()
encoder_optimizer.step()
decoder_optimizer.step()
return loss.item() / target_length
def generateTrainingData(notes, delta, split):
max = 0
data = []
for n in notes:
splitIndex = int(len(n) * split)
x = n[0:splitIndex]
y = n[splitIndex:]
input = encodeNoteList(x, delta)
data.append((input, encodeNoteList(y, delta) + [getStopIndex()], x, y))
if len(input) > max:
max = len(input)
return data, max