用神经网络对信贷项目进行预测

import pandas as pd
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler, StandardScaler, OneHotEncoder, LabelEncoder
import time
import matplotlib.pyplot as plt
from tqdm import tqdm
from imblearn.over_sampling import SMOTE

数据处理

​

# 加载信贷预测数据集
data = pd.read_excel('data.xlsx')
 
# 丢弃掉Id列
data = data.drop(['Id'], axis=1)
 
# 区分连续特征与离散特征
continuous_features = data.select_dtypes(include=['float64', 'int64']).columns.tolist()
discrete_features = data.select_dtypes(exclude=['float64', 'int64']).columns.tolist()
 
# 离散特征使用众数进行补全
for feature in discrete_features:
    if data[feature].isnull().sum() > 0:
        mode_value = data[feature].mode()[0]
        data[feature].fillna(mode_value, inplace=True)
 
# 连续变量用中位数进行补全
for feature in continuous_features:
    if data[feature].isnull().sum() > 0:
        median_value = data[feature].median()
        data[feature].fillna(median_value, inplace=True)
 
# 有顺序的离散变量进行标签编码
mappings = {
    "Years in current job": {
        "10+ years": 10,
        "2 years": 2,
        "3 years": 3,
        "< 1 year": 0,
        "5 years": 5,
        "1 year": 1,
        "4 years": 4,
        "6 years": 6,
        "7 years": 7,
        "8 years": 8,
        "9 years": 9
    },
    "Home Ownership": {
        "Home Mortgage": 0,
        "Rent": 1,
        "Own Home": 2,
        "Have Mortgage": 3
    },
    "Term": {
        "Short Term": 0,
        "Long Term": 1
    }
}
 
# 使用映射字典进行转换
data["Years in current job"] = data["Years in current job"].map(mappings["Years in current job"])
data["Home Ownership"] = data["Home Ownership"].map(mappings["Home Ownership"])
data["Term"] = data["Term"].map(mappings["Term"])
 
# 对没有顺序的离散变量进行独热编码
data = pd.get_dummies(data, columns=['Purpose'])
list_final = []
data2 = pd.read_excel('data.xlsx')
for i in data.columns:
    if i not in data2.columns:
        list_final.append(i)
for i in list_final:
    data[i] = data[i].astype(int)  # 将bool型转换为数值型

​

 神经网络训练

# 分离特征数据和标签数据
X = data.drop(['Credit Default'], axis=1)  # 特征数据
y = data['Credit Default']  # 标签数据
 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
 
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)  # 确保训练集和测试集是相同的缩放
 
X_train = torch.FloatTensor(X_train)
y_train = torch.LongTensor(y_train.values)
X_test = torch.FloatTensor(X_test)
y_test = torch.LongTensor(y_test.values)
 
 
class MLP(nn.Module):
    def __init__(self):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(30, 64)  # 增加第一层神经元数量
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.3)  # 添加Dropout防止过拟合
        self.fc2 = nn.Linear(64, 32)
        self.relu = nn.ReLU()
        self.fc3 = nn.Linear(32, 2)  # 减少隐藏层数，保持输出层不变
 
    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.dropout(out)  # 应用Dropout
        out = self.fc2(out)
        out = self.relu(out)
        out = self.fc3(out)
        return out
 

model = MLP()
 
# 分类问题使用交叉熵损失函数
criterion = nn.CrossEntropyLoss()
 
# 使用随机梯度下降优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)
 
# 训练模型
num_epochs = 20000  # 训练的轮数
 
# 用于存储每200个epoch的损失值、准确率和对应的epoch数
losses = []
accuracies = []
epochs = []
 
start_time = time.time()  # 记录开始时间
 
# 创建tqdm进度条
with tqdm(total=num_epochs, desc="训练进度", unit="epoch") as pbar:
    # 训练模型
    for epoch in range(num_epochs):
        # 前向传播
        outputs = model(X_train)  # 隐式调用forward函数
        loss = criterion(outputs, y_train)
 
        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
 
        # 记录损失值、准确率并更新进度条
        if (epoch + 1) % 200 == 0:
            losses.append(loss.item())
            epochs.append(epoch + 1)
 
            # 在测试集上评估模型
            model.eval()
            with torch.no_grad():
                test_outputs = model(X_test)
                _, predicted = torch.max(test_outputs, 1)
                correct = (predicted == y_test).sum().item()
                accuracy = correct / y_test.size(0)
                accuracies.append(accuracy)
 
            # 更新进度条的描述信息
            pbar.set_postfix({'Loss': f'{loss.item():.4f}', 'Accuracy': f'{accuracy * 100:.2f}%'})
 
        # 每1000个epoch更新一次进度条
        if (epoch + 1) % 1000 == 0:
            pbar.update(1000)  # 更新进度条
 
    # 确保进度条达到100%
    if pbar.n < num_epochs:
        pbar.update(num_epochs - pbar.n)  # 计算剩余的进度并更新
 
time_all = time.time() - start_time  # 计算训练时间
print(f'Training time: {time_all:.2f} seconds')
 
# 绘制损失和准确率曲线
fig, ax1 = plt.subplots(figsize=(10, 6))
 
# 绘制损失曲线
color = 'tab:red'
ax1.set_xlabel('Epoch')
ax1.set_ylabel('Loss', color=color)
ax1.plot(epochs, losses, color=color)
ax1.tick_params(axis='y', labelcolor=color)
 
# 创建第二个y轴用于绘制准确率曲线
ax2 = ax1.twinx()
color = 'tab:blue'
ax2.set_ylabel('Accuracy', color=color)
ax2.plot(epochs, accuracies, color=color)
ax2.tick_params(axis='y', labelcolor=color)
 
plt.title('Training Loss and Accuracy over Epochs')
plt.grid(True)
plt.show()
 
# 在测试集上评估模型，此时model内部已经是训练好的参数了
# 评估模型
model.eval()  # 设置模型为评估模式
with torch.no_grad():  # torch.no_grad()的作用是禁用梯度计算，可以提高模型推理速度
    outputs = model(X_test)  # 对测试数据进行前向传播，获得预测结果
    _, predicted = torch.max(outputs, 1)  # torch.max(outputs, 1)返回每行的最大值和对应的索引
 
    correct = (predicted == y_test).sum().item()  # 计算预测正确的样本数
    accuracy = correct / y_test.size(0)
    print(f'测试集准确率: {accuracy * 100:.2f}%')

@浙大疏锦行