打卡day36

仔细回顾一下神经网络到目前的内容，没跟上进度的同学补一下进度。

• 作业：对之前的信贷项目，利用神经网络训练下，尝试用到目前的知识点让代码更加规范和美观。
• 探索性作业（随意完成）：尝试进入nn.Module中，查看他的方法

在CPU上训练

import  torch
import pandas as pd
import pandas as pd    #用于数据处理和分析，可处理表格数据。
import numpy as np     #用于数值计算，提供了高效的数组操作。
import matplotlib.pyplot as plt    #用于绘制各种类型的图表
import seaborn as sns   #基于matplotlib的高级绘图库，能绘制更美观的统计图形。
 
import  torch.nn as nn
import  torch.optim as optim
from  sklearn.model_selection import train_test_split
from  sklearn.preprocessing import MinMaxScaler
import time 
import matplotlib.pyplot as plt
import pandas as pd

plt.rcParams['font.sans-serif'] = ['SimHei']  # Windows系统常用黑体字体
plt.rcParams['axes.unicode_minus'] = False 

data=pd.read_csv("data.csv")
# 先筛选字符串变量 
discrete_features = data.select_dtypes(include=['object']).columns.tolist()
# Home Ownership 标签编码
home_ownership_mapping = {
    'Own Home': 1,
    'Rent': 2,
    'Have Mortgage': 3,
    'Home Mortgage': 4
}
data['Home Ownership'] = data['Home Ownership'].map(home_ownership_mapping)

# Years in current job 标签编码
years_in_job_mapping = {
    '< 1 year': 1,
    '1 year': 2,
    '2 years': 3,
    '3 years': 4,
    '4 years': 5,
    '5 years': 6,
    '6 years': 7,
    '7 years': 8,
    '8 years': 9,
    '9 years': 10,
    '10+ years': 11
}
data['Years in current job'] = data['Years in current job'].map(years_in_job_mapping)

# Purpose 独热编码，记得需要将bool类型转换为数值
data = pd.get_dummies(data, columns=['Purpose'])
data2 = pd.read_csv("data.csv") # 重新读取数据，用来做列名对比
list_final = [] # 新建一个空列表，用于存放独热编码后新增的特征名
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) # 这里的i就是独热编码后的特征名



# Term 0 - 1 映射
term_mapping = {
    'Short Term': 0,
    'Long Term': 1
}
data['Term'] = data['Term'].map(term_mapping)
data.rename(columns={'Term': 'Long Term'}, inplace=True) # 重命名列
continuous_features = data.select_dtypes(include=['int64', 'float64']).columns.tolist()  #把筛选出来的列名转换成列表
 
 # 连续特征用中位数补全
for feature in continuous_features:     
    mode_value = data[feature].mode()[0]            #获取该列的众数。
    data[feature].fillna(mode_value, inplace=True)          #用众数填充该列的缺失值，inplace=True表示直接在原数据上修改。

# 最开始也说了 很多调参函数自带交叉验证，甚至是必选的参数，你如果想要不交叉反而实现起来会麻烦很多
# 所以这里我们还是只划分一次数据集
from sklearn.model_selection import train_test_split
X = data.drop(['Credit Default'], axis=1)  # 特征，axis=1表示按列删除
y = data['Credit Default'] # 标签
# 按照8:2划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  # 80%训练集，20%测试集


scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# 将数据转换为PyTorch张量并移至GPU
X_train = torch.FloatTensor(X_train)

y_train = torch.LongTensor(y_train.to_numpy())  # 推荐使用 to_numpy() 方法
y_test = torch.LongTensor(y_test)



X_test = torch.FloatTensor(X_test)


class MLP(nn.Module):
    def __init__(self):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(31, 10)  # 输入层到隐藏层
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(10, 2)  # 隐藏层到输出层

    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out

# 实例化模型并移至CPU
model = MLP()

# 分类问题使用交叉熵损失函数
criterion = nn.CrossEntropyLoss()

# 使用随机梯度下降优化器
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 20000  # 训练的轮数

# 用于存储每100个epoch的损失值和对应的epoch数
losses = []

start_time = time.time()  # 记录开始时间

for epoch in range(num_epochs):
    # 前向传播
    outputs = model(X_train)  # 隐式调用forward函数
    loss = criterion(outputs, y_train)

    # 反向传播和优化
    optimizer.zero_grad() #梯度清零，因为PyTorch会累积梯度，所以每次迭代需要清零，梯度累计是那种小的bitchsize模拟大的bitchsize
    loss.backward() #  反向传播计算梯度
    optimizer.step() # 更新参数

    # 记录损失值
    if (epoch + 1) % 200 == 0:
        losses.append(loss.item()) # item()方法返回一个Python数值，loss是一个标量张量
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
    
    # 打印训练信息
    if (epoch + 1) % 100 == 0: # range是从0开始，所以epoch+1是从当前epoch开始，每100个epoch打印一次
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

time_all = time.time() - start_time  # 计算训练时间
print(f'Training time: {time_all:.2f} seconds')


# 可视化损失曲线
plt.plot(range(len(losses)), losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss over Epochs')
plt.show()













Epoch [100/20000], Loss: 0.6014
Epoch [200/20000], Loss: 0.5815
Epoch [200/20000], Loss: 0.5815
Epoch [300/20000], Loss: 0.5768
Epoch [400/20000], Loss: 0.5738
Epoch [400/20000], Loss: 0.5738
Epoch [500/20000], Loss: 0.5709
Epoch [600/20000], Loss: 0.5679
Epoch [600/20000], Loss: 0.5679
Epoch [700/20000], Loss: 0.5650
Epoch [800/20000], Loss: 0.5620
Epoch [800/20000], Loss: 0.5620
Epoch [900/20000], Loss: 0.5590
Epoch [1000/20000], Loss: 0.5560
Epoch [1000/20000], Loss: 0.5560
Epoch [1100/20000], Loss: 0.5531
Epoch [1200/20000], Loss: 0.5502
Epoch [1200/20000], Loss: 0.5502
Epoch [1300/20000], Loss: 0.5475
Epoch [1400/20000], Loss: 0.5448
Epoch [1400/20000], Loss: 0.5448
Epoch [1500/20000], Loss: 0.5423
Epoch [1600/20000], Loss: 0.5398
Epoch [1600/20000], Loss: 0.5398
Epoch [1700/20000], Loss: 0.5374
...
Epoch [19900/20000], Loss: 0.4666
Epoch [20000/20000], Loss: 0.4666
Epoch [20000/20000], Loss: 0.4666
Training time: 14.75 seconds
Output is truncated. View as a scrollable element or open in a text editor. Adjust cell output settings...

在GPU上训练

import  torch
import pandas as pd
import pandas as pd    #用于数据处理和分析，可处理表格数据。
import numpy as np     #用于数值计算，提供了高效的数组操作。
import matplotlib.pyplot as plt    #用于绘制各种类型的图表
import seaborn as sns   #基于matplotlib的高级绘图库，能绘制更美观的统计图形。
 
import  torch.nn as nn
import  torch.optim as optim
from  sklearn.model_selection import train_test_split
from  sklearn.preprocessing import MinMaxScaler
import time 
import matplotlib.pyplot as plt
import pandas as pd

plt.rcParams['font.sans-serif'] = ['SimHei']  # Windows系统常用黑体字体
plt.rcParams['axes.unicode_minus'] = False 

data=pd.read_csv("data.csv")
# 先筛选字符串变量 
discrete_features = data.select_dtypes(include=['object']).columns.tolist()
# Home Ownership 标签编码
home_ownership_mapping = {
    'Own Home': 1,
    'Rent': 2,
    'Have Mortgage': 3,
    'Home Mortgage': 4
}
data['Home Ownership'] = data['Home Ownership'].map(home_ownership_mapping)

# Years in current job 标签编码
years_in_job_mapping = {
    '< 1 year': 1,
    '1 year': 2,
    '2 years': 3,
    '3 years': 4,
    '4 years': 5,
    '5 years': 6,
    '6 years': 7,
    '7 years': 8,
    '8 years': 9,
    '9 years': 10,
    '10+ years': 11
}
data['Years in current job'] = data['Years in current job'].map(years_in_job_mapping)

# Purpose 独热编码，记得需要将bool类型转换为数值
data = pd.get_dummies(data, columns=['Purpose'])
data2 = pd.read_csv("data.csv") # 重新读取数据，用来做列名对比
list_final = [] # 新建一个空列表，用于存放独热编码后新增的特征名
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) # 这里的i就是独热编码后的特征名



# Term 0 - 1 映射
term_mapping = {
    'Short Term': 0,
    'Long Term': 1
}
data['Term'] = data['Term'].map(term_mapping)
data.rename(columns={'Term': 'Long Term'}, inplace=True) # 重命名列
continuous_features = data.select_dtypes(include=['int64', 'float64']).columns.tolist()  #把筛选出来的列名转换成列表
 
 # 连续特征用中位数补全
for feature in continuous_features:     
    mode_value = data[feature].mode()[0]            #获取该列的众数。
    data[feature].fillna(mode_value, inplace=True)          #用众数填充该列的缺失值，inplace=True表示直接在原数据上修改。

# 最开始也说了 很多调参函数自带交叉验证，甚至是必选的参数，你如果想要不交叉反而实现起来会麻烦很多
# 所以这里我们还是只划分一次数据集
from sklearn.model_selection import train_test_split
X = data.drop(['Credit Default'], axis=1)  # 特征，axis=1表示按列删除
y = data['Credit Default'] # 标签
# 按照8:2划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  # 80%训练集，20%测试集



import torch
import torch.nn as nn
import torch.optim as optim
import time
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
import pandas as pd

# 确保设备一致性
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"使用设备: {device}")

# 假设X_train, X_test是DataFrame，y_train, y_test是Series
# （这里只是示例，实际使用时请替换为你的数据加载代码）
# X_train, X_test, y_train, y_test = ...

# 归一化数据
scaler = MinMaxScaler()

try:
    # 处理特征数据
    # 检查X_train类型并转换为numpy数组
    if isinstance(X_train, torch.Tensor):
        # 如果是张量，确保在CPU上并转为numpy
        X_train_np = X_train.cpu().numpy()
        X_test_np = X_test.cpu().numpy()
    else:
        # 如果是DataFrame或ndarray，直接使用values
        X_train_np = X_train.values if isinstance(X_train, pd.DataFrame) else X_train
        X_test_np = X_test.values if isinstance(X_test, pd.DataFrame) else X_test

    # 用scaler拟合和转换
    X_train_scaled = scaler.fit_transform(X_train_np)
    X_test_scaled = scaler.transform(X_test_np)

    # 转回PyTorch张量并移至设备
    X_train = torch.FloatTensor(X_train_scaled).to(device)
    X_test = torch.FloatTensor(X_test_scaled).to(device)

    # 处理标签数据
    # 将pandas Series转换为PyTorch张量
    if isinstance(y_train, pd.Series):
        y_train = torch.LongTensor(y_train.values).to(device)
        y_test = torch.LongTensor(y_test.values).to(device)
    elif isinstance(y_train, torch.Tensor):
        # 如果已是张量，确保类型和设备正确
        y_train = y_train.long().to(device)
        y_test = y_test.long().to(device)
    else:
        # 处理numpy数组情况
        y_train = torch.LongTensor(y_train).to(device)
        y_test = torch.LongTensor(y_test).to(device)

    # 定义MLP模型
    class MLP(nn.Module):
        def __init__(self):
            super(MLP, self).__init__()
            self.fc1 = nn.Linear(31, 10)  # 输入层到隐藏层，31个特征
            self.relu = nn.ReLU()
            self.fc2 = nn.Linear(10, 2)   # 隐藏层到输出层，2个类别
        
        def forward(self, x):
            out = self.fc1(x)
            out = self.relu(out)
            out = self.fc2(out)
            return out

    # 实例化模型并移至设备
    model = MLP().to(device)

    # 分类问题使用交叉熵损失函数
    criterion = nn.CrossEntropyLoss()

    # 使用随机梯度下降优化器
    optimizer = optim.SGD(model.parameters(), lr=0.01)

    # 训练模型
    num_epochs = 20000  # 训练的轮数
    losses = []  # 用于存储每200个epoch的损失值

    start_time = time.time()  # 记录开始时间

    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:
            current_loss = loss.item()
            losses.append(current_loss)
            print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {current_loss:.4f}')
        
        # 每100个epoch打印一次（避免输出过于频繁）
        # 已在200epoch时打印，这里可以注释掉避免重复
        # if (epoch + 1) % 100 == 0:
        #     print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

    training_time = time.time() - start_time  # 计算训练时间
    print(f'Training time: {training_time:.2f} seconds')

    # 在测试集上评估模型
    model.eval()  # 切换到评估模式
    with torch.no_grad():  # 不计算梯度
        outputs = model(X_test)
        _, predicted = torch.max(outputs.data, 1)
        accuracy = (predicted == y_test).sum().item() / y_test.size(0)
        print(f'Test Accuracy: {accuracy:.4f}')

    # 可视化损失曲线
    plt.figure(figsize=(10, 6))
    plt.plot(range(1, len(losses)+1), losses, marker='o', markersize=3)
    plt.xlabel('Epoch (×200)')  # 因为每200个epoch记录一次
    plt.ylabel('Loss')
    plt.title('Training Loss over Epochs')
    plt.grid(True, linestyle='--', alpha=0.7)
    plt.show()

except Exception as e:
    print(f"发生错误: {str(e)}")
    # 打印变量类型帮助调试
    print(f"X_train类型: {type(X_train)}")
    print(f"X_test类型: {type(X_test)}")
    print(f"y_train类型: {type(y_train)}")
    print(f"y_test类型: {type(y_test)}")



使用设备: cuda
Epoch [200/20000], Loss: 0.6009
Epoch [400/20000], Loss: 0.5847
Epoch [600/20000], Loss: 0.5795
Epoch [800/20000], Loss: 0.5745
Epoch [1000/20000], Loss: 0.5692
Epoch [1200/20000], Loss: 0.5636
Epoch [1400/20000], Loss: 0.5578
Epoch [1600/20000], Loss: 0.5518
Epoch [1800/20000], Loss: 0.5462
Epoch [2000/20000], Loss: 0.5410
Epoch [2200/20000], Loss: 0.5362
Epoch [2400/20000], Loss: 0.5318
Epoch [2600/20000], Loss: 0.5278
Epoch [2800/20000], Loss: 0.5241
Epoch [3000/20000], Loss: 0.5208
Epoch [3200/20000], Loss: 0.5177
Epoch [3400/20000], Loss: 0.5149
Epoch [3600/20000], Loss: 0.5124
Epoch [3800/20000], Loss: 0.5099
Epoch [4000/20000], Loss: 0.5077
Epoch [4200/20000], Loss: 0.5055
Epoch [4400/20000], Loss: 0.5035
Epoch [4600/20000], Loss: 0.5016
Epoch [4800/20000], Loss: 0.4997
...
Epoch [19800/20000], Loss: 0.4642
Epoch [20000/20000], Loss: 0.4641
Training time: 13.05 seconds
Test Accuracy: 0.7700
Output is truncated. View as a scrollable element or open in a text editor. Adjust cell output settings...

@浙大疏锦行