Dear @ptrblck, according to your suggestion I have tried to write a simple NN for Binary classification.  But, the training accuracy is not improved-- it is always around 40-50%. And train loss almost stacked on one point after 5-10 iterations.
Here is my code:
class MySmallModel(nn.Module):
    def __init__(self,nodes):
        super(MySmallModel, self).__init__()
        self.fc1 = nn.Linear(nodes, 50)
        self.fc2 = nn.Linear(50, 10)
        self.fc3 = nn.Linear(10, 1)
        
    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = F.relu(self.fc3(x))
        return x

class Classifier(nn.Module):
    def __init__(self,input_nodes):
        super(Classifier, self).__init__()
        self.networks=[]
        self.input_nodes = input_nodes
        
        for i in range(len(input_nodes)):
            self.networks.append(MySmallModel(input_nodes[i]))# number of model = 80
        '''
        self.network1 = MySmallModel(i1)
        self.network2 = MySmallModel(i2)
        self.network3 = MySmallModel(i3)
        '''
        
        self.fc1 = nn.Linear(len(input_nodes), 40)
        self.fc2 = nn.Linear(40, 10)
        self.fc_out = nn.Linear(10, 1)
        
    def forward(self, input_):
        
        x_list=[]
        for i in range(len(self.input_nodes)):
            x_list.append(F.relu(self.networks[i](input_[:,i])))#input_[:,i] shape 500 * 200
            
        x = torch.cat((x_list), 1)
        
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = F.sigmoid(self.fc_out(x))
        return x
 

model = Classifier(input_nodes)
print (model)
criterion = nn.BCELoss()#nn.NLLLoss()
optimizer = optim.SGD(model.parameters(), lr=0.08)

 for e in range(epochs):
    running_loss = 0
    i = 0
    print ('Epochs: ', e)
    for data, label in trainloader:
         y_hat  = model(data) # Shape (500,80,200)
         
         loss = criterion(y_hat, label)
        
         optimizer.zero_grad()
         loss.backward()
         optimizer.step()
        
         y_hat_class = np.where(y_hat.detach().numpy()<0.5, 0, 1)

         accuracy = np.sum(label.numpy()==y_hat_class.flatten()) / len(label)
         print('Train Accuracy: ', accuracy)
         train_accuracy.append(accuracy)
         train_loss.append(loss.item())
        
         running_loss += loss.item()
    else:
        
        print(f"Training loss: {running_loss/len(trainloader)}")

Can you please check the code? Does the first small model train correctly?
Is the training process is correct here?
Here, Shape of the Data = 500 *80*200
for each small model, input = 500*200 (one of the 80 list).
Please help