Sure :

```
class musicLSTM(nn.Module):
def __init__(self,input_size,output_size,hidden_size,deepness):
super().__init__()
self.deepness = deepness
self.input_size = input_size
self.output_size = output_size
self.hidden_size = hidden_size
self.lstm = nn.LSTM(input_size, hidden_size,num_layers = deepness, batch_first = True)
self.output_layer = nn.Linear(hidden_size,output_size)
self.tanh = nn.Tanh()
self.softmax = nn.LogSoftmax(dim = 2)
def forward(self, notes, timing, harmony, hidden = None):
if hidden == None:
hidden = (torch.zeros(self.deepness,1,self.hidden_size),torch.zeros(self.deepness,1,self.hidden_size))
out, hidden = self.lstm(input,hidden)
out = self.tanh(out)
out = self.output_layer(out)
out = self.softmax(out)
else:
out, hidden = self.lstm(input,hidden)
out = self.tanh(out)
out = self.output_layer(out)
out = self.softmax(out)
return out, hidden
```

and the training is done with this function :

```
def train_rnn(model,notes,utils,chords):
start = time.time()
criterion = nn.NLLLoss()
timing_criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters())
n_iters = 1000
print_every = 1
plot_every = 2
all_losses = []
total_loss = 0
for iter in range(1,n_iters+1):
optimizer.zero_grad()
loss = 0
output, hidden = model(notes, timing, harmony)
for i in range(5):
ln = criterion(output[0][i][0:130].unsqueeze(0), targetTensor(notes[0][i+1][0:130]))
lt = timing_criterion(output[0][i][130:135], timing[0][i+1])
lh = criterion(output[0][i][135:246].unsqueeze(0), targetTensor(harmony[0][i+1][0:111]))
loss += ln + lt + lh
loss.backward()
optimizer.step()
total_loss += loss.item() / notes.size(1)
if iter % print_every == 0:
print('%s (%d %d%%) %.2f' % (time_since(start), iter, iter / n_iters * 100, loss))
if iter % plot_every == 0:
all_losses.append(total_loss / plot_every)
total_loss = 0
plt.figure()
plt.plot(all_losses)
```

Defined that way, the training actually only happens on the first 5 notes of the song defined by `notes`

,`timing`

and `harmony`

. Notes has the dimension `(1, melody_length, 130)`

, timing `(1,melody_length, 5)`

and harmony `(1, melody_length, 111)`

. 130 and 111 being the possible pitches and chords available.