I am working on a binary classification problem, where based on the description of a product I have put it under one of the 2 categories. I have used Glove to convert my sentences into 100-dimensional embedding, then I have averaged the embedding for the complete sentence. My problem is that the loss is not decreasing beyond 1.0
My input dimensions are (1,100)
Model architecture is
class NN(nn.Module):
    def __init__(self):
        super(NN,self).__init__()
        self.l1=nn.Linear(100,60)
        kaiming_uniform_(self.l1.weight, nonlinearity='relu')
        self.relu1 = nn.ReLU()
        
        
        self.l2=nn.Linear(60,30)
        kaiming_uniform_(self.l2.weight, nonlinearity='relu')
        self.relu2=nn.ReLU()
        
        self.l3=nn.Linear(30,10)
        kaiming_uniform_(self.l3.weight, nonlinearity='relu')
        self.relu3=nn.ReLU()
        
        self.l4=nn.Linear(10,1)
        xavier_uniform_(self.l4.weight)
        self.sig = nn.Sigmoid() 
#       self.relu=nn.Relu
    def forward(self,x):
        x=self.relu1(self.l1(x))
        x=self.relu2(self.l2(x))
        x=self.relu3(self.l3(x))
        x=self.sig(self.l4(x))
        return x


Data loader
class loader(Dataset):
    def __init__(self):
        pass
    def __len__(self):
        return len(d)
    def __getitem__(self,idx):
        return d["embedding"][idx],d["category"][idx]

Training Loop
criterion = nn.BCELoss()
opt = optim.SGD(net.parameters(), lr=0.00001, momentum=0.9)
epochs=50
batch_size=64
num_iter=500
for epoch_num in range(1,epochs+1):
    running_loss=0.0
    total_train=0
    correct_train=0
    for i,samples in (enumerate(train_loader)):
        emb,label=samples[0].double(),samples[1].double()
#       print(emb.shape,label.shape)
        num=emb.shape[0]
        emb,label=emb.to(device),label.to(device)
        opt.zero_grad()
        outputs=net(emb)
#         print(outputs)
#         break
        outputs=outputs.reshape((outputs.shape[0],1))
        label=label.reshape((label.shape[0],1))
#       print(outputs.shape)
        loss=criterion(outputs,label)
        loss.backward()
        opt.step()

        running_loss+=(torch.exp(loss).item()) *(batch_size/num)
        valid_loss=0
        if(i%num_iter==0 and i!=0):
#           valid_loss=validation(valid_loader=valid_loader,criterion=criterion)
            print("Epoch [%3d] iteration [%4d] loss:[%.10f]"%(epoch_num,i,running_loss/num_iter),end="")
            print()
#           print(" validation_loss:[%.10f]"%(valid_loss),end="")
#           print("acc [%3d] current lr [%.10f]"%(correct_train/total_train,opt.param_groups[0]['lr']))
            running_loss=0.0


            

Thank you.