Hi,
Although you have defined your models in the same way, they almost will never have same results. The reason is that you have just defined layers, each layer has its own parameters like bias, weights which are initialized randomly and as we know about NNs, it may lead to different local optima. So, if you could get identical loss/results, that would be strange.
Also, optimizers, random seeds in different steps all affect the result. If you want to have a fair comparison, you need to force all random generator seeds to a constant number and then use the exact same input for models without even using loss/optimizer.
For issues related to seeding please see randomness 1.
If you run below code, you will get same result:
import torch
torch.manual_seed(0)
np.random.seed(0)

class Net1(nn.Module):
    def __init__(self, ):
        super(Net1, self).__init__()

        self.fusion = nn.Sequential(nn.Conv2d(512, 256, kernel_size=3, stride=1, padding=1, bias=False),
                                            nn.BatchNorm2d(256),
                                            nn.ReLU(inplace=True),
                                            )

        self.get_feat = nn.Sequential(nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1, bias=False),
                                            nn.BatchNorm2d(256),
                                            nn.ReLU(inplace=True),
                                            )

    def forward(self, x):
       feat = self.get_feat(self.fusion(x))
       return feat

class Net2(nn.Module):
    def __init__(self, ):
        super(Net2, self).__init__()
        self.feat_fusion = nn.Sequential(nn.Conv2d(512, 256, kernel_size=3, stride=1, padding=1, bias=False),
                                            nn.BatchNorm2d(256),
                                            nn.ReLU(inplace=True),
                                            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1, bias=False),
                                            nn.BatchNorm2d(256),
                                            nn.ReLU(inplace=True),
                                            )


    def forward(self, x):
       feat = self.feat_fusion(x)
       return feat

torch.manual_seed(0)
net1 = Net1()

torch.manual_seed(0)
net2 = Net2()

torch.manual_seed(0)
x = torch.randn(1, 512, 20, 20)

(net1(x) == net2(x)).all()  # true: two tensors are identical

Bests