玩转ChatGPT：Transformer分类模型_transform分类

一、写在前面

之前，我们介绍了Sklearn包以及Boost辈的各种分类模型，这些模型都很经典了，实际上也很强大，比如说Xgboost。

然而，近期随着ChatGPT的大火，其底层框架Transformer也逐渐火了，现在大家朝着通用人工智能的方向靠拢。因此，我在想，尝试使用Transformer框架做一做临床诊断/预后问题（本质上就是分类问题），看看效果如何。

首先使用GPT简单科普Transformer框架：

二、尝鲜过程

实际上，我对于Transformer框架一概不知。所以，无脑求助GPT。

（1）用TA提供一个基础代码：

咒语：我有一个<临床数据>，其中“X1”列表示病人的预后（0表示生存，1表示死亡），其余列“X3”至“X19”表示临床自变量。

我需要写一个Transformer框架做分类的代码，使用“X3”至“X19”这17个自变量去预测“X1”，请用python帮我写出代码。

数据格式如下：

<

X1 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19

0 0 0 0 0 0 0 2.17 22 6.5 295 1.16 0.08 3.52 224 0.33 0 82.6

0 1 0 0 0 1 0 1.17 23 24.3 261 0.79 0.04 3.75 59 0.27 0.02 53.3

0 0 0 0 0 0 0 1.82 63.99 3.9 460.67 1.2 0.05 4.8 21 0.07 0 38.3

1 0 0 0 1 1 0 2.13 63.99 15.7 401.3 1.24 0.12 5.1 147 0.9 0.01 80.84

>

回复如下：

首先得安装PyTorch，具体安装教程就不说了。算了，还是说一下：

（a）打开Anaconda Prompt；

（b）打开Pytorch官网（https://pytorch.org/）寻找安装命令代码，根据自己的需求选择安装条件，比如我的LOW电脑没有GPU，只能用CPU；

（c）在Anaconda Prompt输入代码安装（记得切换好安装环境）：

conda install pytorch torchvision torchaudio cpuonly -c pytorch

回车安装即可。

再附上GPT给的代码：

import torch
 
import torch.nn as nn
 
import torch.optim as optim
 
from sklearn.model_selection import train_test_split
 
from sklearn.preprocessing import StandardScaler
 
import pandas as pd
 
import numpy as np
 
# 加载数据
 
data = pd.read_csv('your_data.csv')  # 请用您数据的实际路径替换 'your_data.csv'
 
X = data.loc[:, 'X3':'X19'].values
 
y = data['X1'].values
 
# 数据预处理
 
scaler = StandardScaler()
 
X = scaler.fit_transform(X)
 
# 划分数据集
 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
 
# 创建PyTorch数据加载器
 
train_data = torch.utils.data.TensorDataset(torch.Tensor(X_train), torch.Tensor(y_train))
 
test_data = torch.utils.data.TensorDataset(torch.Tensor(X_test), torch.Tensor(y_test))
 
train_loader = torch.utils.data.DataLoader(train_data, batch_size=32, shuffle=True)
 
test_loader = torch.utils.data.DataLoader(test_data, batch_size=32, shuffle=True)
 
# 定义设备
 
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 
# 创建Transformer模型
 
class TransformerModel(nn.Module):
 
    def __init__(self, input_dim, output_dim, nhead=1):
 
        super(TransformerModel, self).__init__()
 
        self.encoder = nn.TransformerEncoder(
 
            nn.TransformerEncoderLayer(d_model=input_dim, nhead=nhead),
 
            num_layers=3
 
        )
 
        self.classifier = nn.Linear(input_dim, output_dim)
 
    def forward(self, x):
 
        x = self.encoder(x)
 
        x = self.classifier(x)
 
        return x
 
# 初始化模型和优化器
 
model = TransformerModel(input_dim=X.shape[1], output_dim=2).to(device)
 
optimizer = optim.Adam(model.parameters(), lr=0.001)
 
criterion = nn.CrossEntropyLoss()
 
# 训练模型
 
for epoch in range(100):
 
    for i, (inputs, labels) in enumerate(train_loader):
 
        inputs, labels = inputs.to(device), labels.to(device)
 
        
 
        optimizer.zero_grad()
 
        
 
        outputs = model(inputs)
 
        loss = criterion(outputs, labels.long())
 
        
 
        loss.backward()
 
        optimizer.step()
 
    print(f'Epoch {epoch+1} / 100: Average Loss: {loss.item()}')

（2）模型需要计算性能参数

写咒语：我还需要做得出模型在训练集和测试集上的性能指标，包括灵敏度、特异度和AUC值，帮我更新代码。

TA又更新了代码（只显示更新的部分）：

# 训练模型
 
for epoch in range(20):
 
    for i, (inputs, labels) in enumerate(train_loader):
 
        inputs, labels = inputs.to(device), labels.to(device)
 
        optimizer.zero_grad()
 
        outputs = model(inputs)
 
        loss = criterion(outputs, labels.long())
 
        loss.backward()
 
        optimizer.step()
 
    # 验证模型
 
    model.eval()
 
    with torch.no_grad():
 
        # 训练集
 
        predictions = []
 
        truths = []
 
        for inputs, labels in train_loader:
 
            inputs, labels = inputs.to(device), labels.to(device)
 
            output = model(inputs)
 
            _, predicted = torch.max(output.data, 1)
 
            predictions += predicted.tolist()
 
            truths += labels.tolist()
 
        tn, fp, fn, tp = confusion_matrix(truths, predictions).ravel()
 
        sensitivity = tp / (tp + fn)
 
        specificity = tn / (tn + fp)
 
        auc = roc_auc_score(truths, predictions)
 
        #print(f'Epoch {epoch+1} / 100, Training: Sensitivity: {sensitivity}, Specificity: {specificity}, AUC: {auc}')
 
 # 测试集
 
        predictions = []
 
        truths = []
 
        for inputs, labels in test_loader:
 
            inputs, labels = inputs.to(device), labels.to(device)
 
            output = model(inputs)
 
            _, predicted = torch.max(output.data, 1)
 
            predictions += predicted.tolist()
 
            truths += labels.tolist()
 
        tn, fp, fn, tp = confusion_matrix(truths, predictions).ravel()
 
        sensitivity = tp / (tp + fn)
 
        specificity = tn / (tn + fp)
 
        auc = roc_auc_score(truths, predictions)
 
        print(f'Epoch {epoch+1} / 100, Testing: Sensitivity: {sensitivity}, Specificity: {specificity}, AUC: {auc}')

把数据带进去运行试试：

可以看到，应该还是有一些过拟合的现象。

（3）继续施咒，如何改善过拟合。

施咒：上述的代码运行后出现过拟合，如何改善？

总体的挺到位的。我们来看看：

数据量就不考虑了，我也想要更多数据。更简单的模型，说的有道理，不过现在是测试这个面模型的性能。早停法也不适合，因为从20次迭代来看，都是过拟合的，你怎么样TA停，同样，交叉验证也是不可行。所以，试试其他的办法。

（4）增加正则化。

咒语：如何在代码中增加正则化项，请帮我改写相关代码段。

然后我加进去了，没啥效果。这是L2正则化，然后又问了L1正则化：

同样效果也不明显。

（5）减少模型复杂度。

咒语：如何做到“减少编码器层的数量、减少自注意力机制的头数或降低前馈神经网络的隐藏单元数量”，请分别修改代码段展示。

GPT注意给了回复，这里我一起展示：

# 创建Transformer模型
 
class TransformerModel(nn.Module):
 
    def __init__(self, input_dim, output_dim, nhead=1):
 
        super(TransformerModel, self).__init__()
 
        self.encoder = nn.TransformerEncoder(
 
            nn.TransformerEncoderLayer(d_model=input_dim, nhead=nhead),
 
            num_layers=int(0.5 * input_dim) # 减少层数
 
        )
 
        self.norm = nn.BatchNorm1d(input_dim)  # 添加批归一化层        
 
        self.classifier = nn.Linear(input_dim, output_dim)
 
        self.dropout = nn.Dropout(1)  # 添加一个dropout层  

然后，效果也是不明显。

看来过拟合不好解决，同时我们可以看到，Sensitivity都是比Specificity要小的，这也可以理解，因为这是一个不平衡数据（正比负是1:3），下一步考虑从这一点入手。

（6）处理不平衡数据。

咒语：Sensitivity远远比Specificity要小，请问如何改进代码？

我们来分析下：重采样就算了，尽量不要动原始数据。第三个看不懂。所以，试试改变阈值。

（7）改变阈值。

咒语：改代码中如何改变阈值？请修改相应代码段。

代码如下：

# 验证模型
 
model.eval()
 
with torch.no_grad():
 
    # 测试集
 
    predictions = []
 
    truths = []
 
    for inputs, labels in test_loader:
 
        inputs, labels = inputs.to(device), labels.to(device)
 
        output = model(inputs)
 
        # 将输出结果用 softmax 函数转换为概率
 
        probabilities = torch.nn.functional.softmax(output, dim=1)
 
        # 调整阈值，例如设定阈值为 0.3
 
        threshold = 0.3
 
        predicted = (probabilities[:, 1] > threshold).long()
 
        predictions += predicted.tolist()
 
        truths += labels.tolist()
 
    tn, fp, fn, tp = confusion_matrix(truths, predictions).ravel()
 
    sensitivity = tp / (tp + fn)
 
    specificity = tn / (tn + fp)
 
    auc = roc_auc_score(truths, predictions)
 
    print(f'Epoch {epoch+1} / 100, Testing: Sensitivity: {sensitivity}, Specificity: {specificity}, AUC: {auc}')

当然值变动了测试集，我们来试试效果，阈值改成0.3：

可以看到，特异度的份额被分到了灵敏度了，总体的AUC值变化不大。因此，性能基本上也就这样了。

最终的代码：

import torch
 
import torch.nn as nn
 
import torch.optim as optim
 
from sklearn.model_selection import train_test_split
 
from sklearn.preprocessing import StandardScaler
 
from sklearn.metrics import confusion_matrix, roc_auc_score
 
import pandas as pd
 
import numpy as np
 
 
 
# 加载数据
 
data = pd.read_csv('Entry model3.csv')  # 请用您数据的实际路径替换 'your_data.csv'
 
X = data.loc[:, 'X3':'X19'].values
 
y = data['X1'].values
 
 
 
# 数据预处理
 
scaler = StandardScaler()
 
X = scaler.fit_transform(X)
 
 
 
# 划分数据集
 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=2338)
 
 
 
# 创建PyTorch数据加载器
 
train_data = torch.utils.data.TensorDataset(torch.Tensor(X_train), torch.Tensor(y_train))
 
test_data = torch.utils.data.TensorDataset(torch.Tensor(X_test), torch.Tensor(y_test))
 
train_loader = torch.utils.data.DataLoader(train_data, batch_size=32, shuffle=True)
 
test_loader = torch.utils.data.DataLoader(test_data, batch_size=32, shuffle=True)
 
 
 
# 定义设备
 
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 
 
 
# 创建Transformer模型
 
class TransformerModel(nn.Module):
 
    def __init__(self, input_dim, output_dim, nhead=1):
 
        super(TransformerModel, self).__init__()
 
        self.encoder = nn.TransformerEncoder(
 
            nn.TransformerEncoderLayer(d_model=input_dim, nhead=nhead),
 
            num_layers=int(0.5 * input_dim) # 减少层数
 
        )
 
        self.norm = nn.BatchNorm1d(input_dim)  # 添加批归一化层        
 
        self.classifier = nn.Linear(input_dim, output_dim)
 
        self.dropout = nn.Dropout(1)  # 添加一个dropout层        
 
 
 
 
 
    def forward(self, x):
 
        x = self.encoder(x)
 
        x = self.classifier(x)
 
        return x
 
 
 
 
 
# 初始化模型和优化器
 
model = TransformerModel(input_dim=X.shape[1], output_dim=2).to(device)
 
optimizer = optim.Adam(model.parameters(), lr=0.0001, weight_decay=1e-5)
 
 
 
criterion = nn.CrossEntropyLoss()
 
 
 
# 训练模型
 
for epoch in range(20):
 
    for i, (inputs, labels) in enumerate(train_loader):
 
        inputs, labels = inputs.to(device), labels.to(device)
 
        
 
        optimizer.zero_grad()
 
        
 
        outputs = model(inputs)
 
        loss = criterion(outputs, labels.long())
 
 
 
        # 添加L1正则化
 
        #l1_lambda = 0.001
 
        #l1_norm = sum(p.abs().sum() for p in model.parameters())
 
        #loss = loss + l1_lambda * l1_norm
 
        
 
        loss.backward()
 
        optimizer.step()
 
    
 
    # 验证模型
 
    model.eval()
 
    with torch.no_grad():
 
        # 训练集
 
        predictions = []
 
        truths = []
 
        for inputs, labels in train_loader:
 
            inputs, labels = inputs.to(device), labels.to(device)
 
            output = model(inputs)
 
            _, predicted = torch.max(output.data, 1)
 
            predictions += predicted.tolist()
 
            truths += labels.tolist()
 
        
 
        tn, fp, fn, tp = confusion_matrix(truths, predictions).ravel()
 
        sensitivity = tp / (tp + fn)
 
        specificity = tn / (tn + fp)
 
        auc = roc_auc_score(truths, predictions)
 
        #print(f'Epoch {epoch+1} / 100, Training: Sensitivity: {sensitivity}, Specificity: {specificity}, AUC: {auc}')
 
        
 
        # 测试集
 
        predictions = []
 
        truths = []
 
        for inputs, labels in test_loader:
 
            inputs, labels = inputs.to(device), labels.to(device)
 
            output = model(inputs)
 
            # 将输出结果用 softmax 函数转换为概率
 
            probabilities = torch.nn.functional.softmax(output, dim=1)
 
            # 调整阈值，例如设定阈值为 0.3
 
            threshold = 0.3
 
            predicted = (probabilities[:, 1] > threshold).long()
 
            predictions += predicted.tolist()
 
            truths += labels.tolist()
 
        tn, fp, fn, tp = confusion_matrix(truths, predictions).ravel()
 
        sensitivity = tp / (tp + fn)
 
        specificity = tn / (tn + fp)
 
        auc = roc_auc_score(truths, predictions)
 
        print(f'Epoch {epoch+1} / 100, Testing: Sensitivity: {sensitivity}, Specificity: {specificity}, AUC: {auc}')

三、总结

以上，Transformer框架能解决分类问题。不过在这个例子中，性能不太好，可能是因为数据量太小了吧（400多例而已）。反而，同样的数据，Xgboost略胜一筹（AUC：0.75），所以有时候，合适的模型才是最好的。