def METHOD_NAME(self, model, sample, reduce=True):
    """Compute the loss for the given sample.
    Returns a tuple with three elements:
    1) the loss
    2) the sample size, which is used as the denominator for the gradient
    3) logging outputs to display while training
    """
    lm_logits, output_metadata = model(**sample["net_input"])
    # reshape lm_logits from (N,T,C) to (N*T,C)
    lm_logits = lm_logits.view(-1, lm_logits.size(-1))
    lm_targets = sample["lm_target"].view(-1)
    lm_loss = compute_cross_entropy_loss(lm_logits, lm_targets, self.padding_idx)
    # compute the number of tokens for which loss is computed. This is used
    # to normalize the loss
    ntokens = utils.strip_pad(lm_targets, self.padding_idx).numel()
    loss = lm_loss / ntokens
    nsentences = sample["nsentences"]
    # nsentences = 0
    # Compute sentence loss if masked_lm_only is False
    sentence_loss = None
    if not self.masked_lm_only:
        sentence_logits = output_metadata["sentence_logits"]
        sentence_targets = sample["sentence_target"].view(-1)
        # This needs to be recomputed due to some differences between
        # TokenBlock and BlockPair dataset. This can be resolved with a
        # refactor of BERTModel which we will do in the future.
        # TODO: Remove this after refactor of BERTModel
        nsentences = sentence_targets.size(0)
        # Check for logits being none which can happen when remove_heads
        # is set to true in the BERT model. Ideally we should set
        # masked_lm_only to true in this case, but that requires some
        # refactor in the BERT model.
        if sentence_logits is not None:
            sentence_loss = compute_cross_entropy_loss(
                sentence_logits, sentence_targets
            )
            loss += self.nsp_loss_weight * (sentence_loss / nsentences)
    # NOTE: as we are summing up per token mlm loss and per sentence nsp loss
    # we don't need to use sample_size as denominator for the gradient
    # here sample_size is just used for logging
    sample_size = 1
    logging_output = {
        "loss": utils.item(loss.data) if reduce else loss.data,
        "lm_loss": utils.item(lm_loss.data) if reduce else lm_loss.data,
        # sentence loss is not always computed
        "sentence_loss": (
            (utils.item(sentence_loss.data) if reduce else sentence_loss.data)
            if sentence_loss is not None
            else 0.0
        ),
        "ntokens": ntokens,
        "nsentences": nsentences,
        "sample_size": sample_size,
    }
    return loss, sample_size, logging_output