In a task I would like to accumulate losses computed from each time-step of a sequence, I can do the following two ways, which I supposed to be equivalent (but seems not):

- Feeding in a single time-step and compute a loss for it, until a sequence is consumed:

```
# note that lstm is initialized with batch_first = True
# the model structure is the common embedding -> lstm -> linear -> softmax
hidden = model.initial_hidden()
loss = 0 # initialize loss for a batch of sequences
for t in range(seq_length):
output, hidden = model(input[:, t, :], hidden)
loss += loss_function(output, y[:, t]) # accumulate loss per time-step
loss.backward()
```

`input.size()`

-> `(batch_size, seq_length, input_size)`

; and

`output.size()`

-> `(batch_size, n_label)`

, is the output of `softmax()`

; and

`y[:,t].size()`

-> `(batch_size)`

, `loss_function`

is `NLLoss()`

.

- Feeding in a whole sequence, and accumulate losses in a for loop

```
hidden = model.initial_hidden()
output, hidden = model(input, hidden)
loss = 0
for t in range(seq_length):
loss += loss_function(output[:, t, :], y[:, t])
loss.backward()
```

in this setting `output.size()`

-> `(batch_size, seq_length, n_label)`

So my question is that whether these two settings are equivalent. In my experiment, setting one is four times slower than setting two, but the accumulated loss is about two times lower (the observation of the first two epochs). Could someone help me out on indicating the essential differences between the two settings, if any?