深度学习kaggle房价预测比赛代码询问

Question

以下是我的代码，还没有写到预测部分只写到训练部分，请问显示代码没问题为何没有显示训练和拟合的结果和图像呢？

import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import numpy as np
import  pandas as pd
import sys
import torchvision
import torchvision.transforms as transforms
sys.path.append("C:/Users/zyx20/Desktop/深度学习编程/pythonProject")
import d2lzh_pytorch as d2l

print(torch.__version__)
torch.set_default_tensor_type(torch.FloatTensor)

train_data=pd.read_csv("C:/Users/zyx20/Desktop/kaggle房价预测/train.csv")
test_data=pd.read_csv("C:/Users/zyx20/Desktop/kaggle房价预测/test.csv")

train_data.shape
test_data.shape

#将所有训练数据和测试数据的79个样本连结
all_features=pd.concat((train_data.iloc[:,1:-1],test_data.iloc[:,1:-1]))
#对连续数值的特征做标准化
numeric_features=all_features.dtypes[all_features.dtypes != 'object'].index
all_features[numeric_features]=all_features[numeric_features].apply(lambda x:(x-x.mean())/(x.std()))
all_features=all_features.fillna(0)

#将离散数值转成指示特征
all_features=pd.get_dummies(all_features,dummy_na=True)
all_features.shape

n_train=train_data.shape[0]
train_features=torch.tensor(all_features[:n_train].values,dtype=torch.float)
test_features=torch.tensor(all_features[n_train:].values,dtype=torch.float)
train_labels=torch.tensor(train_data.SalePrice.values,dtype=torch.float).view(-1,1)

#训练模型
loss=torch.nn.MSELoss()

def get_net(feature_num):
    net=nn.Linear(feature_num,1)
    for param in net.parameters():
        nn.init.normal_(param,mean=0,std=0.01)
    return net

#定义用来评价模型的对数均方根误差
def log_rmse(net,features,labels):
    with torch.no_grad():
        #将小于1的值设置为1，使得取对数时数值更稳定
        clipped_preds=torch.max(net(features),torch.tensor(1.0))
        rmse=torch.sqrt(2*loss(clipped_preds.log(),labels.log()).mean())
    return rmse.item()

def semilogy(x_vals,y_vals,x_label,y_label,x2_vals=None,y2_vals=None,legend=None,figsize=(3.5,2.5)):
    d2l.set_figsize(figsize)
    d2l.plt.xlabel(x_label)
    d2l.plt.ylabel(y_label)
    d2l.plt.semilogy(x_vals,y_vals)
    if x2_vals and y2_vals:
        d2l.plt.semilogy(x2_vals,y2_vals,linestyle=':')
        d2l.plt.legend(legend)

#定义训练函数
def train(net,train_features,train_labels,test_features,test_labels,num_epochs,learning_rate,weight_decay,batch_size):
    train_ls,test_ls=[],[]
    dataset=torch.utils.data.TensorDataset(train_features,train_labels)
    train_iter=torch.utils.data.DataLoader(dataset,batch_size,shuffle=True)
    optimizer=torch.optim.Adam(params=net.parameters(),lr=learning_rate,weight_decay=weight_decay)
    for epoch in range(num_epochs):
        for X,y in train_iter:
            l=loss(net(X.float()),y.float())
            optimizer.zero_grad()
            l.backward()
            optimizer.step()
        train_ls.append(log_rmse(net,train_features,train_labels))
        if test_labels is not None:
            test_ls.append(log_rmse(net,test_features,test_labels))
    return train_ls,test_ls

#K折交叉验证
def get_k_fold_data(k,i,X,y):
    assert k>1
    fold_size=X.shape[0]//k
    X_train,y_train=None,None
    for j in range(k):
        idx=slice(j * fold_size,(j + 1) * fold_size)
        X_part,y_part=X[idx,:],y[idx]
        if j==i:
            X_valid,y_valid=X_part,y_part
        elif X_train is None:
            X_train, y_train =X_part,y_part
        else:
            X_train=torch.cat((X_train,X_part),dim=0)
            y_train = torch.cat((y_train, y_part), dim=0)
    return X_train,y_train,X_valid,y_valid


#在K折交叉验证中我们训练K次并返回训练和验证的平均误差
def k_fold(k,X_train,y_train,num_epochs,learning_rate,weight_decay,batch_size):
    train_l_sum,valid_l_sum=0,0
    for i in range(k):
        data=get_k_fold_data(k,i,X_train,y_train)
        net=get_net(X_train.shape[1])
        train_ls,valid_ls=train(net,*data,num_epochs,learning_rate,weight_decay,batch_size)
        train_l_sum += train_ls[-1]
        valid_l_sum += valid_ls[-1]
        if i ==0:
            semilogy(range(1,num_epochs + 1),train_ls,'epochs','rmse',range(1,num_epochs + 1),valid_ls,['train','valid'])
        print('fold %d,train rmse %f,valid rmse %f' % (i,train_ls[-1],valid_ls[-1]))
    return train_l_sum/k,valid_l_sum/k

plt.show()

Answer 1

引自免费微信小程序：皆我百晓生

您提供的代码中包含了数据预处理、模型定义、损失函数计算、训练过程以及K折交叉验证的过程。然而，这段代码并没有执行任何训练和拟合操作，也没有显示训练结果和图像。

要查看训练和验证的损失变化图像，需要在k_fold函数之后调用训练函数，并且在每次训练迭代完成后，将训练和验证损失添加到train_ls和valid_ls列表中。然后，在训练结束后，调用semilogy函数绘制结果图像。

以下是修改后的代码段，包含实际训练过程：

# 设置超参数
num_epochs = 100
learning_rate = 0.001
weight_decay = 0.001
batch_size = 32

# 运行K折交叉验证并绘制结果
k = 5
train_l_avg, valid_l_avg = k_fold(k, train_features, train_labels, num_epochs, learning_rate, weight_decay, batch_size)

# 显示图像（此处在K折交叉验证循环外部调用semilogy）
plt.show()

请注意，由于你没有提供测试集标签test_labels，所以在train函数中针对测试集的部分不会有任何输出。如果想看到K折交叉验证后每个折的验证损失，你需要确保在k_fold函数内部调用semilogy来实时绘图。

此外，你的原始代码中还有一个问题：train函数中的if test_labels is not None:判断条件在当前环境下永远不会为真，因为在调用k_fold时并未传入test_labels。如果你想在K折交叉验证过程中观察测试集的表现，你需要在k_fold函数里调整逻辑，确保在每一轮折叠中都能使用未参与训练的数据进行验证预测。