下载数据集

# 导入所需的库
import hashlib      # 用于计算文件的SHA-1哈希值，验证文件完整性
import os           # 用于操作系统路径、目录等操作
import tarfile      # 用于处理.tar或.gz压缩文件
import zipfile      # 用于处理.zip压缩文件
import requests     # 用于发送HTTP请求，下载文件

# @save 是d2l库的标记，表示该函数会被保存或复用
DATA_HUB = dict()   # 全局字典，存储数据集名称和对应的(URL, SHA-1哈希值)
DATA_URL = 'http://d2l-data.s3-accelerate.amazonaws.com/'  # 数据集基础URL

def download(name, cache_dir=os.path.join('..', 'data')):  #@save
    """下载一个DATA_HUB中的文件，返回本地文件名"""
    # 断言：确保要下载的文件名在DATA_HUB中已定义
    assert name in DATA_HUB, f"{name} 不存在于 {DATA_HUB}"
    
    # 从DATA_HUB获取URL和期望的SHA-1哈希值
    url, sha1_hash = DATA_HUB[name]
    
    # 创建缓存目录（如果不存在）
    os.makedirs(cache_dir, exist_ok=True)
    
    # 生成本地文件路径：缓存目录 + URL中的文件名
    fname = os.path.join(cache_dir, url.split('/')[-1])
    
    # 如果文件已存在，检查其哈希值是否匹配
    if os.path.exists(fname):
        sha1 = hashlib.sha1()
        # 以二进制模式打开文件，分块读取（每次1MB）
        with open(fname, 'rb') as f:
            while True:
                data = f.read(1048576)  # 1MB = 1024 * 1024
                if not data:
                    break
                sha1.update(data)
        # 如果哈希值匹配，直接返回缓存的文件路径
        if sha1.hexdigest() == sha1_hash:
            return fname  # 命中缓存
    
    # 如果文件不存在或哈希不匹配，则重新下载
    print(f'正在从{url}下载{fname}...')
    r = requests.get(url, stream=True, verify=True)  # 发送GET请求下载文件
    with open(fname, 'wb') as f:
        f.write(r.content)  # 将下载的内容写入文件
    return fname

def download_extract(name, folder=None):  #@save
    """下载并解压zip/tar文件"""
    fname = download(name)  # 调用download函数获取文件路径
    base_dir = os.path.dirname(fname)  # 获取文件所在目录
    data_dir, ext = os.path.splitext(fname)  # 分离文件名和扩展名
    
    # 根据扩展名选择解压方式
    if ext == '.zip':
        fp = zipfile.ZipFile(fname, 'r')  # 打开ZIP文件
    elif ext in ('.tar', '.gz'):
        fp = tarfile.open(fname, 'r')     # 打开TAR/GZ文件
    else:
        assert False, '只有zip/tar文件可以被解压缩'
    
    # 解压到基础目录
    fp.extractall(base_dir)
    
    # 如果指定了子文件夹，返回该子文件夹路径；否则返回解压后的目录
    return os.path.join(base_dir, folder) if folder else data_dir

def download_all():  #@save
    """下载DATA_HUB中的所有文件"""
    for name in DATA_HUB:
        download(name)

# 如果没有安装pandas，请取消下一行的注释
# !pip install pandas

# 设置matplotlib为内联模式，图像直接显示在Notebook中
%matplotlib inline

# 导入常用库
import numpy as np       # 数值计算库
import pandas as pd      # 数据处理和分析库
import torch             # PyTorch深度学习框架
from torch import nn     # PyTorch神经网络模块
from d2l import torch as d2l  # 导入d2l的PyTorch版本

# 定义Kaggle房价预测训练集的信息
DATA_HUB['kaggle_house_train'] = (  #@save
    DATA_URL + 'kaggle_house_pred_train.csv',  # 文件URL
    '585e9cc93e70b39160e7921475f9bcd7d31219ce')  # 文件的SHA-1哈希值

# 定义Kaggle房价预测测试集的信息
DATA_HUB['kaggle_house_test'] = (  #@save
    DATA_URL + 'kaggle_house_pred_test.csv',
    'fa19780a7b011d9b009e8bff8e99922a8ee2eb90')

# 下载并读取训练数据到pandas DataFrame
train_data = pd.read_csv(download('kaggle_house_train'))

# 下载并读取测试数据到pandas DataFrame
test_data = pd.read_csv(download('kaggle_house_test'))

主要功能总结：

1. download()：智能下载文件，支持缓存和完整性校验（SHA-1）。

2. download_extract()：下载并自动解压压缩文件。

3. download_all()：批量下载所有数据集。

结果:

数据预处理(key 不熟)

all_features = pd.concat(
    (train_data.iloc[:, 1:-1], 
     test_data.iloc[:, 1:])
)

把训练集的特征列和测试集的特征列拼在一起，形成一个新的 DataFrame(因为是pandas)。(没想到)

合并训练和测试集的特征（为了统一预处理）

结果:

填充缺失值和归一化特征

# 特征预处理
# 1. 识别数值特征
numeric_features = all_features.dtypes[all_features.dtypes != 'object'].index

# 2. 数值特征标准化（Z-score标准化）
# 注意：这里使用了整个数据集（训练+测试）计算均值和标准差
# 实际生产中应该只使用训练集统计量
all_features[numeric_features] = all_features[numeric_features].apply(
    lambda x: (x - x.mean()) / (x.std())
)

# 3. 标准化后，缺失值用0填充（因为标准化后均值为0）
all_features[numeric_features] = all_features[numeric_features].fillna(0)

# 4. 类别特征进行独热编码，dummy_na=True会将缺失值也视为一个类别
all_features = pd.get_dummies(all_features, dummy_na=True)

# 获取特征数量
print(f"预处理后的特征维度: {all_features.shape}")

# 分离回训练和测试集
n_train = train_data.shape[0]  # 训练集样本数
train_features = torch.tensor(all_features[:n_train].values, dtype=torch.float32)
test_features = torch.tensor(all_features[n_train:].values, dtype=torch.float32)

# 获取训练标签
train_labels = torch.tensor(
    train_data.SalePrice.values.reshape(-1, 1), dtype=torch.float32
)

# 打印数据形状
print(f"训练特征形状: {train_features.shape}")
print(f"训练标签形状: {train_labels.shape}")
print(f"测试特征形状: {test_features.shape}")

1细节 处理连续数据 取出数字列

指的是和object比较得到结果是布尔型序列(因为有很多个特征列) 下图所示

取出索引(类似于字典)

2细节 数字列归一化

先标准化再填充缺失值

处理离散特征，独热编码:

机器学习中处理离散特征（分类特征）的一种常用方法，叫做独热编码（One-Hot Encoding）。

简单来说，它的目的是把文字类别变成计算机能读懂的数字向量。

1. 为什么要这么做？

原始的表格里，像 MSZoning（ zoning 分类）这样的列，里面的值是文字，比如 "RL"（住宅低密）, "RM"（住宅中等密）, 或者是空的（NaN）。

• 计算机不认识字：模型只能计算数字。

• 不能随便编数字：如果你把 "RL" 编成 1，"RM" 编成 2，模型可能会误以为 "RM" 比 "RL" 大，或者它们有高低之分，但这在现实中是不成立的（它们是平等的类别）。

2. 它是怎么工作的？（以 "RL" 为例）

独热编码的做法是：既然它们是平等的，那就给每个类别发一个专属的“开关”（0或1）。

不再有MSZoning这个列了

检查结果是否正确:

# 检查每一列的数据类型
print(all_features.dtypes)

# 找出所有非数值类型的列（object 或 string）
non_numeric_cols = all_features.select_dtypes(include=['object', 'string']).columns
print("以下列是非数值类型，导致了报错：")
print(non_numeric_cols)

弄出训练集和测试集(分割，因为最开始时候concat了)

通过values属性，我们可以 [从pandas格式中提取NumPy格式，并将其转换为张量表示]用于训练。

# 获取训练集的样本数量（行数）
n_train = train_data.shape[0]  # train_data.shape[0]返回训练数据的行数，即样本数量

# 从合并的特征数据all_features中取出前n_train行作为训练特征
# all_features[:n_train] 通过切片获取前n_train行（训练集部分）
# .values 将DataFrame转换为NumPy数组
# torch.tensor(...) 将NumPy数组转换为PyTorch张量，并指定数据类型为float32
train_features = torch.tensor(all_features[:n_train].values, dtype=torch.float32)

# 从合并的特征数据all_features中取出从n_train行开始到最后一行的数据作为测试特征
# all_features[n_train:] 获取从第n_train行开始到最后一行的数据（测试集部分）
# 同样转换为PyTorch张量
test_features = torch.tensor(all_features[n_train:].values, dtype=torch.float32)

# 获取训练集的标签（房价）
# train_data.SalePrice 是训练集中的房价列
# .values 转换为NumPy数组
# .reshape(-1, 1) 将一维数组转换为二维数组，形状为[n, 1]（n行1列）
# 这里-1表示自动计算该维度的大小，即自动根据原数组元素数量和指定的其他维度（1）来推断
# 例如，原数组有1460个元素，reshape(-1, 1)就会转换成1460行1列的二维数组
# 最后将其转换为PyTorch张量，数据类型为float32
train_labels = torch.tensor(
    train_data.SalePrice.values.reshape(-1, 1), dtype=torch.float32)

训练:

以简单的线性模型为baseline作为对比的

# 定义均方误差损失函数（Mean Squared Error Loss）
loss = nn.MSELoss()

# 获取输入特征的维度，即特征的数量
# train_features.shape[1] 返回训练特征张量的列数，即每个样本的特征数
in_features = train_features.shape[1]

# 定义一个函数用于创建神经网络模型
def get_net():
    # 使用nn.Sequential定义一个简单的线性回归模型
    # 该模型只包含一个全连接层（Linear），输入维度为in_features，输出维度为1
    net = nn.Sequential(nn.Linear(in_features,1))
    return net

# 定义一个函数，计算对数均方根误差（Log Root Mean Squared Error）
# 在房价预测任务中，通常使用对数均方根误差作为评估指标，因为房价的分布通常是偏态的，取对数可以使误差更接近正态分布
def log_rmse(net, features, labels):
    # 使用模型net对特征features进行预测
    # 通过torch.clamp将预测值限制在1到正无穷之间，避免取对数时出现负值或零（因为log(0)是负无穷，log(负数)是NaN）
    clipped_preds = torch.clamp(net(features), 1, float('inf'))
    # 计算对数均方根误差：
    # 1. 对预测值和真实值分别取对数
    # 2. 计算两者之间的均方误差（使用之前定义的MSE损失函数）
    # 3. 对均方误差开方，得到均方根误差
    rmse = torch.sqrt(loss(torch.log(clipped_preds),
                           torch.log(labels)))
    # 返回一个标量（Python浮点数），通过.item()将张量转换为浮点数
    return rmse.item()

# 定义训练函数
def train(net, train_features, train_labels, test_features, test_labels,
          num_epochs, learning_rate, weight_decay, batch_size):
    # 初始化两个列表，分别用于记录训练集和测试集在每个epoch后的对数均方根误差
    train_ls, test_ls = [], []
    
    # 使用d2l库中的load_array函数，将训练特征和训练标签转换为一个可以迭代的数据加载器
    # 每次迭代返回一个批次的数据（包含batch_size个样本）
    train_iter = d2l.load_array((train_features, train_labels), batch_size)
    
    # 定义优化器，这里使用Adam优化算法
    # net.parameters()返回网络中所有需要训练的参数
    # lr：学习率
    # weight_decay：权重衰减（L2正则化）系数，用于防止过拟合
    optimizer = torch.optim.Adam(net.parameters(),
                                 lr = learning_rate,
                                 weight_decay = weight_decay)
    
    # 开始训练，迭代num_epochs个周期
    for epoch in range(num_epochs):
        # 每个epoch中，遍历数据加载器中的每一个批次
        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))
        # 如果提供了测试标签（即test_labels不为None），则计算测试集上的对数均方根误差并记录
        if test_labels is not None:
            test_ls.append(log_rmse(net, test_features, test_labels))
    # 返回训练和测试过程中每个epoch的对数均方根误差列表
    return train_ls, test_ls

k折交叉验证:重点

获取k折数据+进行k折验证:

# 定义一个函数，用于获取K折交叉验证中第i折的训练数据和验证数据
def get_k_fold_data(k, i, X, y):
    # 断言k必须大于1，因为至少需要2折才能进行交叉验证
    assert k > 1
    # 计算每一折的大小（样本数），这里使用整数除法，所以可能不能整除，余数部分被忽略
    fold_size = X.shape[0] // k
    # 初始化训练数据和标签为None
    X_train, y_train = None, None
    # 遍历k折
    for j in range(k):
        # 计算当前折的索引范围，slice对象用于切片
        idx = slice(j * fold_size, (j + 1) * fold_size)
        # 根据索引切片获取当前折的特征和标签
        X_part, y_part = X[idx, :], y[idx]
        # 如果当前折是第i折，则作为验证集
        if j == i:
            X_valid, y_valid = X_part, y_part
        # 否则，将当前折合并到训练集中
        # 如果训练集为空，则直接赋值
        elif X_train is None:
            X_train, y_train = X_part, y_part
        # 如果训练集不为空，则通过torch.cat在0维度（行方向）进行拼接
        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

# 定义一个函数，执行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()
        # 训练模型，并返回训练和验证的误差列表
        # 注意：这里使用了*data将返回的四个值作为参数传递给train函数
        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')
        # 打印当前折的训练和验证误差（最后一轮）
        print(f'折{i + 1}，训练log rmse{float(train_ls[-1]):f}, '
              f'验证log rmse{float(valid_ls[-1]):f}')
    # 返回K折交叉验证的平均训练误差和平均验证误差
    return train_l_sum / k, valid_l_sum / k

核心思想：把训练数据分成K份，轮流用其中K-1份训练，1份验证，重复K次，取平均结果。

类比：

你有5个老师教同一个学生，每个老师用4/5的内容教，用剩下的1/5考试，最后看5个老师的平均分数。

例子:

eg:

# 遍历5折
for j in range(5):
    idx = slice(j*200, (j+1)*200)  # 当前折的索引范围
    
    if j == 0:  # 第0折 → 验证集
        X_valid, y_valid = X[0:200], y[0:200]
    elif j == 1:  # 第1折 → 训练集第一部分
        X_train, y_train = X[200:400], y[200:400]
    else:  # 第2,3,4折 → 拼接到训练集
        X_train = torch.cat([X_train, X[400:600]], 0)  # 第2折
        # ...继续拼接

划分数据代码解读:

我习惯第一种拼接写法

# 对比两种写法：

# 写法1：先创建空列表，再拼接
X_train_parts = []
for j in range(k):
    if j != i:  # 如果不是验证折
        X_train_parts.append(X_part)
# 最后用torch.cat拼接所有部分

# 写法2：当前代码的写法
X_train = None
for j in range(k):
    if j != i:  # 如果不是验证折
        if X_train is None:  # 第一次遇到训练折
            X_train = X_part
        else:  # 后续训练折
            X_train = torch.cat([X_train, X_part], 0)

0 1是dim参数的值

验证代码解读:

------------------

----------------------

train_l_sum += train_ls[-1]  # 只取最后一个epoch来加入
# 但有时最佳模型在中间epoch
# 应该取验证误差最小的那个epoch  但为了初学者懂

 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]

和return train_l_sum / k, valid_l_sum / k 关系:

每个epoch都进行k折验证

 train_ls, valid_ls是训练了num_epochs的结果 最后 train_l_sum每次都只用最后一个epoch结果

所以最后 train_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}')

上图是选择了一组未调优的超参数，并将其留给读者来改进模型。 找到一组调优的超参数可能需要时间，这取决于一个人优化了多少变量。 有了足够大的数据集和合理设置的超参数，折交叉验证往往对多次测试具有相当的稳定性。 然而，如果我们尝试了不合理的超参数，我们可能会发现验证效果不再代表真正的误差。

有时一组超参数的训练误差可能非常低，但折交叉验证的误差要高得多， 这表明模型过拟合了。 在整个训练过程中，我们希望监控训练误差和验证误差这两个数字。 较少的过拟合可能表明现有数据可以支撑一个更强大的模型， 较大的过拟合可能意味着我们可以通过正则化技术来获益。

用全部数据(已经得到合适的超参数了)来训练:

def train_and_pred(train_features, test_features, train_labels, test_data,
                   num_epochs, lr, weight_decay, batch_size):
    """
    完整的训练和预测函数
    
    参数:
    train_features: 训练集特征 (Tensor)
    test_features: 测试集特征 (Tensor)
    train_labels: 训练集标签 (Tensor)
    test_data: 原始的测试数据集 (Pandas DataFrame，包含Id列)
    num_epochs: 训练轮数
    lr: 学习率
    weight_decay: 权重衰减 (L2正则化系数)
    batch_size: 批次大小
    """
    
    # 1. 创建新的神经网络模型实例
    net = get_net()
    
    # 2. 使用全部训练数据训练模型
    # train函数的第4、5个参数设为None，表示不传入验证集/测试集
    # 所以只返回训练误差列表train_ls，第二个返回值用_接收表示忽略
    train_ls, _ = train(net, train_features, train_labels, None, None,
                        num_epochs, lr, weight_decay, batch_size)
    
    # 3. 绘制训练误差随训练轮次变化的曲线
    d2l.plot(np.arange(1, num_epochs + 1),  # x轴：1到num_epochs
             [train_ls],                     # y轴：训练误差列表
             xlabel='epoch',                 # x轴标签
             ylabel='log rmse',              # y轴标签
             xlim=[1, num_epochs],           # x轴范围
             yscale='log')                   # y轴使用对数刻度（误差值通常较小）
    
    # 4. 打印最终训练误差
    print(f'训练log rmse：{float(train_ls[-1]):f}')
    
    # 5. 使用训练好的模型在测试集上进行预测
    # net(test_features)：模型前向传播，得到预测结果
    # .detach()：从计算图中分离，不记录梯度
    # .numpy()：转换为NumPy数组
    preds = net(test_features).detach().numpy()
    
    # 6. 将预测结果重新格式化以便导出到Kaggle
    # preds.reshape(1, -1)：将预测结果重塑为1行多列的二维数组
    # [0]：取第一行（因为是1行，所以就是取所有预测值）
    # pd.Series：转换为Pandas Series，方便添加到DataFrame
    test_data['SalePrice'] = pd.Series(preds.reshape(1, -1)[0])
    
    # 7. 创建提交文件
    # 提取测试集的Id列和预测的SalePrice列
    submission = pd.concat([test_data['Id'], test_data['SalePrice']], axis=1)
    
    # 8. 将结果保存为CSV文件，用于Kaggle提交
    # index=False：不保存行索引
    submission.to_csv('submission.csv', index=False)

train_and_pred(train_features, test_features, train_labels, test_data,
               num_epochs, lr, weight_decay, batch_size)

输入数据
    ↓
创建新模型
    ↓
用全部训练数据训练
    ↓
绘制训练误差曲线
    ↓
打印最终训练误差
    ↓
在测试集上预测
    ↓
格式化预测结果
    ↓
保存为提交文件

细节:

竞赛总结:

10行代码战胜90%数据科学家？

10行代码战胜90%数据科学家？_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1rh411m7Hb/?from=search&seid=14820697425740410884&spm_id_from=333.788.comment.all.click&vd_source=5252d3cdd5246bf9326ccfc5acb9064410行代码战胜90%数据科学家？_哔哩哔哩_bilibili
第三h2o：

https://www.kaggle.com/wuwawa/automl-using-h2o
第四 随机森林：

https://www.kaggle.com/jackzh/the-4th-place-approach-random-forest

https://www.bilibili.com/video/BV15Q4y1o7vc/?spm_id_from=333.999.0.0&vd_source=5252d3cdd5246bf9326ccfc5acb90644

MLP效果不好

eg:

1有些特征文本很多，比如房子介绍

可以直接舍弃文本信息/transform等处理 但不能onehot编码，因为不会有两个文本一样的数据，这样维度就很高了，数据里面是10w条这样

2 数据较大

房子价格美金 差距很大，可以先取log再归一化处理

评分较高的automl:一样是集成模型

【机器学习】解放双手！AutoML入门：从原理到Auto-sklearn实战，告别繁琐调参_automl 开源框架-CSDN博客

：

一、 文本特征（地址、介绍）怎么处理？

在传统的机器学习中，直接把“我爱我家，温馨两居”这种文本扔进树模型（如XGBoost/LightGBM）是不行的。不能直接塞进去，必须先进行“结构化”或“向量化”提取。

1. 地址类文本：靠“正则表达式”提取标签

地址往往很长，但包含的关键信息（学区、地铁、商圈）对房价影响巨大。不要试图把整个地址字符串当作一个特征，而是要用正则把关键信息抠出来变成数值或类别：

• 提取硬性配套：用正则匹配是否包含“地铁”、“学区”、“三甲医院”、“万达广场”等关键词，转换成 has_subway(0或1)、school_district(学区等级) 等布尔或数值特征。

• 结构化解析：比如把“广州市天河区珠江新城保利心语”拆解成 城市=广州、行政区=天河、商圈=珠江新城、小区=保利心语。

• 高阶玩法（聚类）：如果小区名称有几千个，可以计算每个小区的历史均价，然后用 K-Means 把这几千个小区聚类成 5-10 个档次（如：豪宅盘、刚需盘），用聚类的标签代替原始小区名，既降维又保留了地理价值。

2. 介绍类文本（房源描述）：靠“Embedding”获取语义

对于“南北通透，采光极佳，拎包入住”这种描述心情和状态的文本：

• 传统方法（TF-IDF）：简单粗暴，把词变成数字。但如果介绍太长，维度会爆炸，容易过拟合。

• 深度学习方法（强烈推荐）：使用 NLP 领域的预训练模型（如 BERT、Word2Vec）。

  • 把一段介绍文本输入 BERT，它会输出一个固定长度（比如 768 维）的向量。

  • 这个向量就代表了这段描述的“整体语义氛围”。

  • 将这个向量作为额外的特征拼接到你的表格数据中，能让模型理解“豪华装修”和“毛坯简装”在语义上的巨大差异。

---

二、 公榜和私榜是什么意思？

这是数据科学竞赛（如 Kaggle）最核心的机制，也是你提到的第三点“数据切分”的真正用意。

1. 基本定义

• 公榜 (Public Leaderboard)：比赛期间实时更新的排行榜。你的模型在一部分隐藏的测试数据上跑出的分数会显示在这里，所有人都能看到你的实时排名。

• 私榜 (Private Leaderboard)：比赛结束后才揭晓的排行榜。你的模型在另一部分更深度的隐藏数据上跑分，这决定了你的最终奖金和获奖资格。

2. 为什么要分公榜和私榜？（防作弊与防过拟合）

这就回到了你说的“时间切分”：前6个月训练，公榜是后3个月，私榜是再后3个月。

• 公榜的作用：给你的模型一个“试错反馈”。让你知道模型能不能推广到稍微未来的数据。

• 私榜的作用：终极审判。用来检验你的模型是不是真的学到了普适规律，还是在公榜那3个月的数据上“死记硬背”（过拟合）了。

3. 实战中的“致命陷阱”：Shake-Up（排名震荡）

如果你为了让公榜排名更高，疯狂地针对公榜那3个月的数据调参、加特征，你的模型就会完美适应公榜，但到了私榜（再后3个月，市场行情可能变了，尤其这个房价预测，波动太大了）就会一塌糊涂。