尽管仅使用其他标签，模型仅预测错误的标签，并且特异性为0，但灵敏度高？ 型号求解器代码

如何解决尽管仅使用其他标签，模型仅预测错误的标签，并且特异性为0，但灵敏度高？ 型号求解器代码

这可能有点远，但是我不确定还能做什么。我的问题是，我目前有一个应该执行二进制分类的模型。训练后，我注意到敏感性很高（约98％），但特异性接近0。这是由于我的模型仅预测1的事实。

为了检查模型是否正确训练，我对数据进行了过滤，以使我的数据样本仅带有标签0。但是，结果是相同的（只有1个预测），这使我相信我的模型没有正确训练（如果有的话）。

代码如下：

型号

import torch
import torch.nn as nn
import torch.nn.functional as F


class Model(nn.Module):
    def __init__(self,num,dim):
        super().__init__()
        self.hidden_dim = 100
        self.embedding_dim = 300
        self.dropout_p = 0.8
        self.feature_dim = dim
        self.num = num

        self.features_linear = nn.Linear(in_features=self.feature_dim,out_features=self.hidden_dim)
        nn.init.xavier_uniform_(self.features_linear.weight)

        self.embedding = nn.Embedding(num_embeddings=self.num,embedding_dim=self.embedding_dim)
        nn.init.xavier_uniform_(self.embedding.weight)

        self.output_linear = nn.Linear(in_features=(self.hidden_dim + self.embedding_dim),out_features=1)
        nn.init.xavier_uniform_(self.output_linear.weight)

    def forward(self,a,b):
        a_out = F.relu(self.features_linear(a))
        b_emb = self.embedding(b)
        b_sum = torch.sum(b_emb,dim=1)

        input_rep = torch.cat((a_out,b_sum),dim=1)
        input_rep = self.dropout(input_rep)
        output = self.output_linear(input_rep)

        return output

求解器代码。

from sklearn.metrics import confusion_matrix
import torch
import torch.optim as optim


model = Model(num=16,dim=189)
criterion = nn.BCELoss(reduction='mean')
optimizer = optim.Adam(params=model.parameters())

with open(file='train_data.pkl',mode='rb') as f:
    train_data = pickle.load(f)

for epoch in range(200):
    epoch_loss = 0.0
    predicted_targets = []
    ground_truth_targets = []

    for batch in train_data:
        optimizer.zero_grad()

        input_1,input_2,input_3,input_4,label = batch

        if torch.cuda.is_available():
            input_1 = input_1.to('cuda')
            input_2 = input_2.to('cuda')
            input_3 = input_3.to('cuda')
            input_4 = input_4.to('cuda')
            label = label.to('cuda')

        output = input_2

        for i in range(len(input_3)):
            input_data = torch.cat([input_1,output.view(1,-1),input4[i].view(1,-1)],dim=1)
            output = torch.sigmoid(model(input_data,input_3[i].unsqueeze(dim=0)))

        loss = criterion(output,label.float().view(1,-1))
        epoch_loss += loss.item()

        loss.backward()
        optimizer.step()

        output_start = input_2.cpu().item()
        output_end = output.cpu().item()
        label_threshold = output_end / output_start
        prediction = 1 if label_threshold <= 0.1 else 0

        predicted_targets.append(prediction)
        ground_truth_targets.append(label.cpu().item())

    tn,fp,fn,tp = confusion_matrix(ground_truth_targets,predicted_targets).ravel()

    sensitivity = tp / (tp + fn)
    specificity = tn / (tn + fp)

    if epoch % 5 == 0:
        print('Epoch: %d | loss: %.6f | sens: %.4f | spec: %.4f' % (epoch,epoch_loss,sensitivity,specificity)

很抱歉，如果代码有点长，我试图保持最小的基本框架完好无损。可以找到数据here。

如果任何人都可以对可能出现的问题提供反馈或任何想法，将不胜感激。我一直在尝试找出过去几周出了什么问题，但没有任何运气。谢谢！