I am getting this error for the MLP that I am creating. Please help [I am new to this]!
def hidden_init(layer):
    fan_in = layer.weight.data.size()[0]
    lim = 0.5 / np.sqrt(fan_in)
    return (-lim, lim)

class Network(nn.Module):
    def __init__(self, input_dim, hidden1_dim, hidden2_dim, seed, init):
        super(Network, self).__init__()
        #have a seed for reproducability
        self.seed = torch.manual_seed(seed)
        self.fc1 = nn.Linear(input_dim, hidden1_dim)
        self.fc2 = nn.Linear(hidden1_dim, hidden2_dim)
        self.fc3 = nn.Linear(hidden2_dim, 3)
        self.nonlin = nn.ReLU()
        if init:
            self.reset_parameters()
            
    def reset_parameters(self):
        self.fc1.weight.data.uniform_(*hidden_init(self.fc1))
        self.fc2.weight.data.uniform_(*hidden_init(self.fc2))
        self.fc3.weight.data.uniform_(*hidden_init(self.fc3))
        
    def forward(self, x):
        h1 = self.nonlin(self.fc1(x))
        h2 = self.nonlin(self.fc2(h1))
        h3 = self.fc3(h2)
        return h3

def train(model, loss_criterion, optimizer, data_loader):
    losses = []
    avg_loss = []
    for epoch in range(0, 100):
        model.train()
        epoch_loss = 0.0
        for batch_no, (inputs, target_labels) in enumerate(data_loader):
            print(batch_no)
            optimizer.zero_grad()
            vals= model(inputs)
            target_labels = target_labels.view(-1)
            loss = loss_criterion(vals, target_labels//2)
            epoch_loss += loss.item()
            loss.backward()
            optimizer.step()
            
        losses.append(epoch_loss)
        avgl = epoch_loss/1318.0
        avg_loss.append(avgl)
        
        print("Epoch: {} Loss: {:.4f} AvgLoss {:.4f}".format(epoch, epoch_loss, avgl))

    return losses, avg_loss

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

class MyDataset(data.Dataset):

    

    def __init__(self, size, inputdf, labeldf):

        super(MyDataset, self).__init__()

        self.size = size

        self.inputdf = inputdf

        self.labeldf = labeldf

        

    def __len__(self):

        return self.size

    def __getitem__(self, index):

        x = torch.from_numpy(self.inputdf.iloc[index,1:].to_numpy()).float().to(device)

        y = torch.from_numpy(self.labeldf.iloc[index,1:].to_numpy()).long().to(device)

        return x , y

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

data_train = MyDataset(1318, train_final, Y)
data_test = MyDataset(378, test_final, Y_test)
data_train_loader = data.DataLoader(data_train, batch_size =378, shuffle=True, num_workers=1)
data_test_loader = data.DataLoader(data_test, batch_size =378, shuffle=False, num_workers=1)


import numpy as np

model = Network(41,1000,300,5000,True)
optimizer = optim.SGD(model.parameters(), lr=0.0001)
lc = torch.nn.CrossEntropyLoss()
#lc = nn.MSELoss()

total_loss, avg_loss = train(model, lc, optimizer, data_train_loader)
test_total_loss, correct, y_true, y_pred = test(model, data_test_loader, lc)

The last block of code is giving the error:
0
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-123-94b11632a3db> in <module>()
      6 #lc = nn.MSELoss()
      7 
----> 8 total_loss, avg_loss = train(model, lc, optimizer, data_train_loader)
      9 test_total_loss, correct, y_true, y_pred = test(model, data_test_loader, lc)

4 frames
<ipython-input-119-1970596fbe6c> in train(model, loss_criterion, optimizer, data_loader)
     10             vals= model(inputs)
     11             target_labels = target_labels.view(-1)
---> 12             loss = loss_criterion(vals, target_labels//2)
     13             epoch_loss += loss.item()
     14             loss.backward()

/usr/local/lib/python3.7/dist-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs)
    725             result = self._slow_forward(*input, **kwargs)
    726         else:
--> 727             result = self.forward(*input, **kwargs)
    728         for hook in itertools.chain(
    729                 _global_forward_hooks.values(),

/usr/local/lib/python3.7/dist-packages/torch/nn/modules/loss.py in forward(self, input, target)
    960     def forward(self, input: Tensor, target: Tensor) -> Tensor:
    961         return F.cross_entropy(input, target, weight=self.weight,
--> 962                                ignore_index=self.ignore_index, reduction=self.reduction)
    963 
    964 

/usr/local/lib/python3.7/dist-packages/torch/nn/functional.py in cross_entropy(input, target, weight, size_average, ignore_index, reduce, reduction)
   2466     if size_average is not None or reduce is not None:
   2467         reduction = _Reduction.legacy_get_string(size_average, reduce)
-> 2468     return nll_loss(log_softmax(input, 1), target, weight, None, ignore_index, None, reduction)
   2469 
   2470 

/usr/local/lib/python3.7/dist-packages/torch/nn/functional.py in nll_loss(input, target, weight, size_average, ignore_index, reduce, reduction)
   2260     if input.size(0) != target.size(0):
   2261         raise ValueError('Expected input batch_size ({}) to match target batch_size ({}).'
-> 2262                          .format(input.size(0), target.size(0)))
   2263     if dim == 2:
   2264         ret = torch._C._nn.nll_loss(input, target, weight, _Reduction.get_enum(reduction), ignore_index)

ValueError: Expected input batch_size (378) to match target batch_size (756).