Dependence of the WER on batch size in val set? 
**Describe the bug**

Trained the QuartzNet15x5 from scratch on the dataset An4 for 200 epochs. When I try to calculate the WER using the method given in the first tutorial, I noticed a strange dependence of the batch size on the size of the resulting error value. The larger the batch size, the smaller the error, what is the reason for this behaviour? 
Results looks like that: 
4 batch wer0.51
8 batch wer0.46
16 batch wer0.44
32 batch wer0.439
64 batch wer0.434
128 batch wer0.430
256 batch wer0.434
512 batch wer0.404
1024 batch wer0.399
2048 batch wer0.397
4096 batch wer0.398

**Steps/Code to reproduce bug**

    # Bigger batch-size = bigger throughput
    params['model']['validation_ds']['batch_size'] = 4096

    # Setup the test data loader and make sure the model is on GPU
    first_asr_model.setup_test_data(test_data_config=params['model']['validation_ds'])
    first_asr_model.cuda()

    # We will be computing Word Error Rate (WER) metric between our hypothesis and predictions.
    # WER is computed as numerator/denominator.
    # We'll gather all the test batches' numerators and denominators.
    wer_nums = []
    wer_denoms = []

    # Loop over all test batches.
    # Iterating over the model's `test_dataloader` will give us:
    # (audio_signal, audio_signal_length, transcript_tokens, transcript_length)
    # See the AudioToCharDataset for more details.
    for test_batch in first_asr_model.test_dataloader():

            test_batch = [x.cuda() for x in test_batch]
            targets = test_batch[2]
            targets_lengths = test_batch[3]        



            log_probs, encoded_len, greedy_predictions = first_asr_model(
                input_signal=test_batch[0], input_signal_length=test_batch[1]
            )
            # Notice the model has a helper object to compute WER
            first_asr_model._wer.update(greedy_predictions, targets, targets_lengths)
            _, wer_num, wer_denom = first_asr_model._wer.compute()

            first_asr_model._wer.reset()
            wer_nums.append(wer_num.detach().cpu().numpy())
            wer_denoms.append(wer_denom.detach().cpu().numpy())

            # Release tensors from GPU memory
            del test_batch, log_probs, targets, targets_lengths, encoded_len, greedy_predictions

    # We need to sum all numerators and denominators first. Then divide.
    print(f"WER = {sum(wer_nums)/sum(wer_denoms)}")


**Expected behavior**

I thought that nothing should change and the size of the validation batch only determines the speed at which the error is calculated 

**Environment overview (please complete the following information)**

 - Environment location: [Collab]
