Kaggle房价预测

代码详解：

1.数据的读取

#分别为（1459，81）（1460，80）
train_data = pd.read_csv('kaggle_house_train')
test_data = pd.read_csv(('kaggle_house_test'))

2.数据进行合并（将训练集和测试集进行合并）

#进行划分，所有的行加上从第一列到最后倒数第二列。测试集是从第一列到最后一列。合并好的数据没有包含序号，也没有包含价格
#pd.concat默认是按照行进行拼接的
all_features = pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:]))

3.对数据进行预处理

将特征中不是object的类型的索引标号全部取出来 最后得到都是一些数字型所表示的特征。

#,index是取出来索引，将不是object的类型的索引取出来。这些将会是一些数字类型的数据。
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()))
# 在标准化数据之后，所有均值消失，因此我们可以将缺失值设置为0,在此并没有使用均值进行填充，只是使用了0来进行填充。


all_features[numeric_features] = all_features[numeric_features].fillna(0)

简单的进行数据对比

转换数据类型

#将数据转换为张量tensor。因为是二维数组，所以获取[0]就是得到的数据的所有行。
n_train = train_data.shape[0]
#print(n_train)
#在这里只输出来每一行的数据，通过标准化进行处理后的数据
#print(all_features[:n_train].values)
#print(all_features[:n_train].index)
train_features = torch.tensor(all_features[:n_train].values, dtype=torch.float32)
test_features = torch.tensor(all_features[n_train:].values, dtype=torch.float32)
#reshape的意思是将其变为n行1列的数据,再将其变成tensor张量,labels的意思就是数据的价格，标签，真实值。
train_labels = torch.tensor(train_data.SalePrice.values.reshape(-1, 1), dtype=torch.float32)
#print(train_data.SalePrice.values)

训练

#=============================训练
#定义损失函数
loss = nn.MSELoss()
#得到所有的列的个数
in_features = train_features.shape[1]
#print(in_features)

#列的个数就是神经网络的输入，单层的神经网络。输入是331，输出是1的网络模型
def get_net():
    net = nn.Sequential(nn.Linear(in_features,1))
    return net


def log_rmse(net, features, labels):
    # 为了在取对数时进一步稳定该值，将小于1的值设置为1,jiang将区间缩紧到1-无所谓
    clipped_preds = torch.clamp(net(features), 1, float('inf'))
    #预测出来的数值：clipped_preds。标签的值：labels
    rmse = torch.sqrt(loss(torch.log(clipped_preds),torch.log(labels)))
    return rmse.item()

#使用训练函数来进行优化
def train(net, train_features, train_labels, test_features, test_labels,
          num_epochs, learning_rate, weight_decay, batch_size):
    #这里是记录损失函数的大小的
    train_ls, test_ls = [], []
    #将总共的数据进行分批处理，对其进行小批量梯度下降处理
    train_iter = d2l.load_array((train_features, train_labels), batch_size)#转化为Dataloader的数据类型。
    # 这里使用的是Adam优化算法
    optimizer = torch.optim.Adam(net.parameters(),
                                 lr = learning_rate,
                                 weight_decay = weight_decay)

    #迭代的次数
    for epoch in range(num_epochs):
        for X, y in train_iter:
            optimizer.zero_grad()
            l = loss(net(X), y)
            l.backward()
            optimizer.step()
        #记录每一个epoch的损失大小
        #训练集的损失和测试集的损失评判标准是不一样的。
        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折交叉验证
#k是几折交叉
#i是第几次循环
#X是数据集
#y是标签
#其本质是将一份数据，分为5份，然后将其中的44份作为训练集，另外一份作为测试集来使用。
def get_k_fold_data(k, i, X, y):
    #使用断言，如果k不是大于1的话那么就会直接退出这个循环了
    assert k > 1

    #de得到的是数据的总共数目。将数据平均分为5份。
    fold_size = X.shape[0] // k
    X_train, y_train = None, None


    for j in range(k):
        #slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。参数分别为起始位置，结束位置，间距。
        '''
        j = 0 1 2 3 4
        0 - 292
        292 - 584
        584 - 876
        '''
        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], 0)
            y_train = torch.cat([y_train, y_part], 0)
    return X_train, y_train, X_valid, y_valid

#返回训练后和验证误差的平均值
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里面，前面两个是训练集的数据信息，后面是测试集的数据信息。
        data = get_k_fold_data(k, i, X_train, y_train)
        net = get_net()
        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:
            d2l.plot(list(range(1, num_epochs + 1)), [train_ls, valid_ls],
                     xlabel='epoch', ylabel='rmse', xlim=[1, num_epochs],
                     legend=['train', 'valid'], yscale='log')
            #plt.show()
        print(f'折{i + 1}，训练log rmse{float(train_ls[-1]):f}, '
              f'验证log rmse{float(valid_ls[-1]):f}')
    return train_l_sum / k, valid_l_sum / k


k, num_epochs, lr, weight_decay, batch_size = 5, 100, 5, 0, 64
train_l, valid_l = k_fold(k, train_features, train_labels, num_epochs, lr,
                          weight_decay, batch_size)
print(f'{k}-折验证: 平均训练log rmse: {float(train_l):f}, '
      f'平均验证log rmse: {float(valid_l):f}')

数据下载：

https://download.csdn.net/download/guoguozgw/87413305