I can’t reproduce what you said, in my test, when outputs and targets are of same shapes, then whatever w/ or w/o loss.backward(). Outcomes of AdjMSELoss() and MSELoss are identical.
Here is my script
import torch
import torch.nn as nn


class TestModel(nn.Module):
    def __init__(self, idim: int):
        super().__init__()
        self.linear = nn.Linear(idim, 1)

    def forward(self, x: torch.Tensor):
        return self.linear(x)

class AdjMSELoss(nn.Module):
    def __init__(self):
        super().__init__()

    def forward(self, outputs, targets):
        outputs = torch.squeeze(outputs)
        loss = (outputs - targets)**2
        return torch.mean(loss)


def test():
    model = TestModel(5)
    optimizer = torch.optim.SGD(model.parameters(), lr=0.001)
    model.train()
    torch.set_grad_enabled(True)
    criterion = nn.MSELoss()
    criterion2 = AdjMSELoss()

    for i in range(1):
        inputs = torch.randn(4, 5)
        targets = torch.randn(4)
        y_pred = model(inputs)

        loss = criterion(y_pred.squeeze(), targets)
        optimizer.zero_grad()
        # invoke the backward function here
        loss.backward()
        optimizer.step()

        loss2 = criterion2(y_pred, targets)
        print(loss==loss2)
        print("iter {}: {} loss: {:.3e}".format(i, criterion, loss))
        print("iter {}: {} loss: {:.3e}".format(i, criterion2, loss2))


if __name__ == "__main__":
    test()

And output is
>>> tensor(True)
>>> iter 0: MSELoss() loss: 3.582e-01
>>> iter 0: AdjMSELoss() loss: 3.582e-01