yes, It seems The c_loss is not working in itself.
class Classifier(nn.Module):
    def __init__(self, input_feat_dim, hidden_dim1,num_classes):
        """
        Single hidden layer classifier
        with softmax output.
        """
        super(Classifier, self).__init__()
        self.fc5 = nn.Linear(input_feat_dim, hidden_dim1)
        self.fc6 = nn.Linear(hidden_dim1, num_classes)
        self.relu1 = nn.ReLU()
        self.softmax=nn.Softmax(dim=1)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        x = F.relu(self.fc5(x))
        x = F.softmax(self.fc6(x), dim=-1)
        return x

class GCNModelVAE(nn.Module):
    def __init__(self, input_feat_dim, hidden_dim1, hidden_dim2,num_classes, dropout):
        super(GCNModelVAE, self).__init__()
        self.gc1 = GraphConvolution(input_feat_dim, hidden_dim1, dropout, act=F.relu)
        self.gc2 = GraphConvolution(hidden_dim1, hidden_dim2, dropout, act=lambda x: x)
        self.gc3 = GraphConvolution(hidden_dim1, hidden_dim2, dropout, act=lambda x: x)
        self.dc = InnerProductDecoder(dropout, act=lambda x: x)
        self.classifier = Classifier(hidden_dim2,64,num_classes)

    def encode(self, x, adj):
        hidden1 = self.gc1(x, adj)
        return self.gc2(hidden1, adj), self.gc3(hidden1, adj)

    def reparameterize(self, mu, logvar):
        if self.training:
            std = torch.exp(logvar)
            eps = torch.randn_like(std)
            return eps.mul(std).add_(mu)
        else:
            return mu

    def forward(self, x, adj):
        mu, logvar = self.encode(x, adj)
        z = self.reparameterize(mu, logvar)
        return self.dc(z), mu, logvar,self.classifier(mu)


def loss_function(preds, labels, mu, logvar,true_label,predicted_label, n_nodes, norm, pos_weight):
    c_loss=F.binary_cross_entropy_with_logits(predicted_label, true_label)
    return c_loss

for epoch in range(args.epochs):
        t = time.time()
        model.train()
        true_label = Onehotencoder(True_labels,num_classes)
        optimizer.zero_grad()
        recovered, mu, logvar,predicted_label = model(features, adj_norm)
        loss = loss_function(preds=recovered, labels=adj_label,
                             mu=mu, logvar=logvar,true_label=true_label,predicted_label=predicted_label, n_nodes=n_nodes,
                             norm=norm, pos_weight=pos_weight)
        
        loss.backward()
        cur_loss = loss.item()
        optimizer.step()
        _, idx = torch.max(predicted_label, dim=1)
        print('Classification accuracy is ',(idx.numpy()==True_labels).sum()/len(True_labels))
        hidden_emb = mu.data.numpy()
        roc_curr, ap_curr = get_roc_score(hidden_emb, adj_orig, val_edges, val_edges_false)

        print("Epoch:", '%04d' % (epoch + 1), 
              "train_loss=", "{:.5f}".format(cur_loss),
              "val_ap=", "{:.5f}".format(ap_curr),
              "time=", "{:.5f}".format(time.time() - t)
              )

Loss is not going down and classification accuracy is fluctuating. If possible, can you help me in the above classification.