Python训练营-Day49

import torch
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
from tqdm import tqdm 
import pandas as pd
 
 
data = pd.read_csv(r'data.csv')
 
list_discrete = data.select_dtypes(include=['object']).columns.tolist()
 
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_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)
 
data = pd.get_dummies(data, columns=['Purpose'])
data2 = pd.read_csv(r'data.csv')
list_new = []
for i in data.columns:
    if i not in data2.columns:
        list_new.append(i)
for i in list_new:
    data[i] = data[i].astype(int)
 
term_mapping = {'Short Term': 0, 'Long Term': 1}
data['Term'] = data['Term'].map(term_mapping)
data.rename(columns={'Term': 'Long Term'}, inplace=True)
 
list_continuous = data.select_dtypes(
    include=['int64', 'float64']).columns.tolist()
 
for i in list_continuous:
    median_value = data[i].median()
    data[i] = data[i].fillna(median_value)
 
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)
 
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
print(f'使用设备: {device}\n')
 
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
X_train = torch.FloatTensor(X_train).to(device)
y_train = torch.LongTensor(y_train.values).to(device)
X_test = torch.FloatTensor(X_test).to(device)
y_test = torch.LongTensor(y_test.values).to(device)
 
class MLP_Original(nn.Module):
    def __init__(self):
        super(MLP_Original, self).__init__()
        self.fc1 = nn.Linear(31, 10)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(10, 3)
 
    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out
 
class MLP_Larger(nn.Module):
    def __init__(self):
        super(MLP_Larger, self).__init__()
        self.fc1 = nn.Linear(31, 20)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(20, 10)
        self.fc3 = nn.Linear(10, 3)
 
    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        out = self.relu(out)
        out = self.fc3(out)
        return out
 
class MLP_Smaller(nn.Module):
    def __init__(self):
        super(MLP_Smaller, self).__init__()
        self.fc1 = nn.Linear(31, 5)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(5, 3)
 
    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out
 
class MLP_Tanh(nn.Module):
    def __init__(self):
        super(MLP_Tanh, self).__init__()
        self.fc1 = nn.Linear(31, 10)
        self.act = nn.Tanh()
        self.fc2 = nn.Linear(10, 3)
 
    def forward(self, x):
        out = self.fc1(x)
        out = self.act(out)
        out = self.fc2(out)
        return out
 
def train_and_evaluate(model_class, optimizer_class, lr, num_epochs=20000):
    model = model_class().to(device)
    criterion = nn.CrossEntropyLoss()
    optimizer = optimizer_class(model.parameters(), lr=lr)
    
    losses = []
    epochs = []
    start_time = time.time()
    
    with tqdm(total=num_epochs, desc=f'训练 {model_class.__name__}', unit='epoch') as pbar:
        for epoch in range(num_epochs):
            outputs = model(X_train)
            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)
                pbar.set_postfix({'Loss': f'{loss.item():.4f}'})
 
            if (epoch + 1) % 1000 == 0:
                pbar.update(1000)
 
        if pbar.n < num_epochs:
            pbar.update(num_epochs - pbar.n)
 
    time_all = time.time() - start_time
    
    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'{model_class.__name__} 训练时间: {time_all:.2f}秒, 测试准确率: {accuracy:.4f}\n')
    
    return epochs, losses, accuracy
 
configs = [
    (MLP_Original, optim.SGD, 0.01),
    (MLP_Larger, optim.SGD, 0.01),
    (MLP_Smaller, optim.SGD, 0.01),
    (MLP_Tanh, optim.SGD, 0.01),
    (MLP_Original, optim.Adam, 0.001),
    (MLP_Original, optim.SGD, 0.1),
    (MLP_Original, optim.SGD, 0.001)
]
 
plt.figure(figsize=(12, 8))
for config in configs:
    epochs, losses, accuracy = train_and_evaluate(*config)
    plt.plot(epochs, losses, label=f'{config[0].__name__} {config[1].__name__} lr={config[2]} (Acc:{accuracy:.2f})')
 
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss Comparison with Different Hyperparameters')
plt.legend()
plt.grid(True)
plt.show()

@浙大疏锦行