【机器学习项目】使用 PyTorch 预测汽车价格（详细报告+代码详解）

一、实验背景

  随着机器学习和人工智能的迅速发展，预测模型在各个领域的应用变得越来越广泛。其中，预测汽车价格是一个重要且实用的应用领域。准确地预测汽车价格对于汽车制造商、经销商和消费者来说都具有重要意义。
  传统的汽车定价模型通常基于经验公式和统计方法，而现代的机器学习方法则提供了更强大的工具来进行汽车价格预测。PyTorch是一个流行的开源深度学习框架，它提供了丰富的工具和功能，可以用于构建和训练各种类型的神经网络模型。
  本实验旨在使用PyTorch构建一个预测汽车价格的模型。通过训练一个深度神经网络模型，我们可以利用汽车的各种特征（如品牌、型号、年份、里程数等）来预测汽车的价格。这将为汽车制造商和消费者提供一个有价值的工具，帮助他们做出更准确的定价和购买决策。

二、模型介绍

  PyTorch是一个开源的Python机器学习框架，由Facebook的人工智能研究团队开发和维护。它提供了丰富的工具和库，用于构建深度学习模型并进行高效的训练。
  下面是PyTorch的一些重要特点和概念：

1. 动态计算图：PyTorch使用动态计算图，这意味着计算图是在运行时动态生成的。这使得PyTorch更加灵活，可以通过简单的Python控制流语句进行模型定义和操作。与静态计算图相比（如TensorFlow），动态计算图使得调试和模型迭代更加直观和容易。
2. 张量操作：PyTorch提供了一套丰富的张量操作函数，类似于NumPy数组操作。张量是PyTorch的核心数据结构，类似于多维数组，可以存储和处理数字数据。通过PyTorch的张量操作，可以执行各种数学运算、索引和切片操作，以及与其他张量之间的运算。
3. 自动求导：PyTorch的自动求导机制是其重要的特性之一。通过设置requires_grad属性，可以跟踪张量上的操作，并自动计算梯度。这使得在训练神经网络时，可以方便地计算损失函数相对于模型参数的梯度，从而进行反向传播和优化。
4. 神经网络模块：PyTorch提供了一个模块化和可扩展的接口，用于构建神经网络模型。可以通过继承torch.nn.Module类来定义自己的模型，并在其中定义前向传播函数。这个接口简化了模型的定义和组织，并提供了许多内置的层和函数，如卷积层、全连接层、激活函数等。
5. 数据加载和预处理：PyTorch提供了一系列用于加载和处理数据的工具。torchvision库提供了常用的计算机视觉数据集的加载和预处理函数，而torchtext库则专注于自然语言处理任务的数据处理。此外，PyTorch还提供了DataLoader类，用于批量加载和迭代数据，方便进行训练和验证。
6. 分布式训练支持：PyTorch支持分布式训练，允许在多个GPU或多台机器上进行模型的并行训练。它提供了用于多进程和多线程训练的工具，并通过torch.nn.DataParallel和torch.nn.DistributedDataParallel模块简化了模型的并行化。
7. 丰富的生态系统：PyTorch拥有庞大而活跃的社区，提供了各种扩展和库，用于模型压缩、模型解释性、迁移学习等领域。此外，PyTorch还与其他流行的Python库（如NumPy和SciPy）以及深度学习框架（如TensorFlow）之间有良好的互操作性。

  PyTorch是一个灵活而强大的深度学习框架，它结合了动态计算图、自动求导和丰富的工具集，使得构建和训练深度学习模型变得简单而高效。

三、数据集介绍

  本实验采用一个二手汽车的数据集，这个数据集包含了二手汽车的信息。该实验数据集可点击该百度网盘链接获取：数据集链接。该数据集有 258 行和 9 列，每一行代表一辆汽车，每一列代表不同的属性。以下是每列的属性说明：

  • Car_Name: 汽车的名称或型号
  • Year: 汽车的制造年份
  • Selling_Price: 汽车的销售价格（单位：万卢比）
  • Present_Price: 汽车的当前价格（新车价格，单位：万卢比）
  • Kms_Driven: 汽车已行驶的公里数
  • Fuel_Type: 汽车的燃料类型（如汽油、柴油、CNG等）
  • Seller_Type: 卖家类型（个人或经销商）
  • Transmission: 汽车的变速器类型（手动或自动）
  • Owner: 汽车的所有者数量

  其中"Selling_Price"是目标变量。通过对这些特征进行分析，可以了解二手汽车市场的趋势、不同特征与销售价格之间的关系以及其他相关信息。

四、使用 PyTorch 预测汽车价格

1. 导入库

import torch
import jovian
import torch.nn as nn
import pandas as pd
import matplotlib.pyplot as plt
import torch.nn.functional as F
from torch.utils.data import DataLoader, TensorDataset, random_split

代码解释：
  这段代码导入了一些常用的Python库和模块，并且提供了一些数据处理和机器学习的功能。下面是对每行代码的详细解释：

1. import torch: 导入PyTorch库，PyTorch是一个用于机器学习的开源深度学习框架。
2. import jovian: 导入Jovian库，Jovian是一个用于记录和分享机器学习实验的库。
3. import torch.nn as nn: 导入PyTorch中的nn模块，该模块提供了构建神经网络的类和函数。
4. import pandas as pd: 导入Pandas库，Pandas是一个用于数据分析和处理的库。
5. import matplotlib.pyplot as plt: 导入Matplotlib库，Matplotlib是一个用于绘制图表和可视化数据的库。
6. import torch.nn.functional as F: 导入PyTorch中的functional模块，该模块提供了一些常用的函数，如激活函数。
7. from torch.utils.data import DataLoader, TensorDataset, random_split: 从PyTorch的utils.data模块中导入DataLoader、TensorDataset和random_split类。DataLoader用于加载数据集，TensorDataset用于创建包含输入和目标张量的数据集，random_split用于将数据集随机划分为训练集和验证集。

2. 读取数据集

现在，让我们读取数据：

dataframe_raw = pd.read_csv( "car_data.csv")
dataframe_raw.head()

运行结果如下：

代码解释：

1. pd.read_csv("car_data.csv") 使用 Pandas 库的 read_csv() 函数读取名为 “car_data.csv” 的CSV文件，并将文件中的数据解析为一个 DataFrame 对象。DataFrame 是 Pandas 中用于存储和操作表格数据的数据结构。
2. dataframe_raw.head() 显示 DataFrame 对象 dataframe_raw 的前几行数据，默认显示前5行。这个方法可以帮助你快速查看数据的结构和内容。

  这段代码读取名为 “car_data.csv” 的CSV文件，并将其内容存储在 dataframe_raw 变量中，然后显示数据的前几行。

3. 数据处理

your_name = "ChengxuWan" # at least 5 characters
def customize_dataset(dataframe_raw, rand_str):
    dataframe = dataframe_raw.copy(deep=True)
    # drop some rows
    dataframe = dataframe.sample(int(0.95*len(dataframe)), random_state=int(ord(rand_str[0])))
    # scale input
    dataframe.Year = dataframe.Year * ord(rand_str[1])/100.
    # scale target
    dataframe.Selling_Price = dataframe.Selling_Price * ord(rand_str[2])/100.
    # drop column
    if ord(rand_str[3]) % 2 == 1:
        dataframe = dataframe.drop(['Car_Name'], axis=1)
    return dataframe

dataframe = customize_dataset(dataframe_raw, your_name)
dataframe.head()

运行结果如下：

代码解释：
  这段代码定义了一个名为 customize_dataset 的函数，该函数根据输入的 dataframe_raw 和 rand_str 参数进行数据处理和定制，然后返回处理后的数据。
  以下是对每行代码的详细解释：

1. your_name = "ChengxuWan"：定义了一个名为 your_name 的变量，并将其设置为字符串 “ChengxuWan”。此变量用于作为处理数据集的随机种子。
2. def customize_dataset(dataframe_raw, rand_str):：定义了一个名为 customize_dataset 的函数，该函数接受两个参数 dataframe_raw 和 rand_str，用于进行数据集的处理和定制。
3. dataframe = dataframe_raw.copy(deep=True)：创建了一个名为 dataframe 的变量，将 dataframe_raw 的副本复制给它。这样做是为了避免直接修改原始数据。
4. dataframe = dataframe.sample(int(0.95*len(dataframe)), random_state=int(ord(rand_str[0])))：通过使用 sample() 方法从数据集中随机选择一部分数据进行采样。采样数量为原始数据集长度的 95%（即抽取 95% 的数据），并使用 random_state 参数设置随机种子为 ord(rand_str[0]) 的 ASCII 值。
5. dataframe.Year = dataframe.Year * ord(rand_str[1])/100.：对 dataframe 中的 “Year” 列进行缩放处理，将其乘以 ord(rand_str[1]) 的 ASCII 值除以 100。
6. dataframe.Selling_Price = dataframe.Selling_Price * ord(rand_str[2])/100.：对 dataframe 中的 “Selling_Price” 列进行缩放处理，将其乘以 ord(rand_str[2]) 的 ASCII 值除以 100。
7. if ord(rand_str[3]) % 2 == 1:：根据 ord(rand_str[3]) 的 ASCII 值是否为奇数，判断是否执行以下代码块。
8. dataframe = dataframe.drop(['Car_Name'], axis=1)：从 dataframe 中删除 “Car_Name” 列，axis=1 表示删除的是列而不是行。
9. return dataframe：返回处理后的数据集 dataframe。
10. dataframe = customize_dataset(dataframe_raw, your_name)：调用 customize_dataset 函数，并将 dataframe_raw 和 your_name 作为参数传递给它，将返回的处理后的数据集赋值给 dataframe。
11. dataframe.head()：显示 dataframe 的前几行数据，用于查看处理后的数据集的结构和内容。

  在上面的这个函数中，我们删除对预测没有帮助的列，这里我们删除汽车名称。同时我们看到它需要一个词作为随机字符串来随机排序数据，我使用我的名字作为随机字符串。之后我们可以使用自定义数据集，为简单起见，我们可以创建包含行数、列数的变量和包含数字、分类或输出列的变量：

input_cols = ["Year","Present_Price","Kms_Driven","Owner"] 
categorical_cols = ["Fuel_Type","Seller_Type","Transmission"] 
output_cols = ["Selling_Price"]

4. 数据准备

  我们将使用 PyTorch 通过机器学习预测汽车价格，因此要使用数据进行训练，我们需要将其从数据帧转换为 PyTorch 张量，第一步是转换为 NumPy 数组：

def dataframe_to_arrays(dataframe):
    # Make a copy of the original dataframe
    dataframe1 = dataframe.copy(deep=True)
    # Convert non-numeric categorical columns to numbers
    for col in categorical_cols:
        dataframe1[col] = dataframe1[col].astype('category').cat.codes
    # Extract input & outupts as numpy arrays
    inputs_array = dataframe1[input_cols].to_numpy()
    targets_array = dataframe1[output_cols].to_numpy()
    return inputs_array, targets_array

代码解释：
  这段代码定义了一个名为 dataframe_to_arrays 的函数，这个函数的作用是将数据集中的非数值型分类列转换为数字编码，并将输入特征和目标列提取为 NumPy 数组，以便于后续的数据处理和模型训练。以下是对每行代码的详细解释：

1. def dataframe_to_arrays(dataframe):：定义了一个名为 dataframe_to_arrays 的函数，该函数接受一个参数 dataframe，表示输入的数据集。
2. dataframe1 = dataframe.copy(deep=True)：创建了一个名为 dataframe1 的变量，将输入的数据集 dataframe 的副本复制给它。这样做是为了避免直接修改原始数据。
3. for col in categorical_cols:：对于分类特征列表 categorical_cols 中的每一列名 col，执行以下代码块。
4. dataframe1[col] = dataframe1[col].astype('category').cat.codes：将数据集中的非数值型分类列转换为数字编码。首先，使用 astype('category') 将列的数据类型转换为 Pandas 中的 categorical 类型，然后使用 cat.codes 将每个分类值映射为相应的数字编码。这样可以将非数值型的分类数据转换为数值型，便于后续处理。
5. inputs_array = dataframe1[input_cols].to_numpy()：将经过转换后的输入特征列提取为一个 NumPy 数组，赋值给 inputs_array。input_cols 列表指定了要提取的输入特征列。
6. targets_array = dataframe1[output_cols].to_numpy()：将经过转换后的目标列提取为一个 NumPy 数组，赋值给 targets_array。output_cols 列表指定了要提取的目标列。
7. return inputs_array, targets_array：返回转换后的输入特征数组 inputs_array 和目标数组 targets_array。

inputs_array, targets_array = dataframe_to_arrays(dataframe)
inputs_array, targets_array

运行结果如下：

代码解释：
  这段代码调用了 dataframe_to_arrays 函数，并将返回的输入特征数组赋值给 inputs_array，目标数组赋值给 targets_array。然后，通过打印 inputs_array 和 targets_array，我们可以查看转换后的输入特征数组和目标数组的内容。

  现在有了这些数组，我们可以将它们转换为 PyTorch 张量，并使用这些张量创建包含它们的可变数据集：

inputs = torch.Tensor(inputs_array)
targets = torch.Tensor(targets_array)

dataset = TensorDataset(inputs, targets)
train_ds, val_ds = random_split(dataset, [228, 57])
batch_size = 128

train_loader = DataLoader(train_ds, batch_size, shuffle=True)
val_loader = DataLoader(val_ds, batch_size)

代码解释：
  这段代码使用转换后的输入特征数组 inputs_array 和目标数组 targets_array 创建了一个 PyTorch 的数据集对象 dataset。以下是对每行代码的详细解释：

1. inputs = torch.Tensor(inputs_array)：将输入特征数组 inputs_array 转换为 PyTorch 的张量对象 inputs。torch.Tensor() 函数用于将数据转换为张量对象，以便在 PyTorch 中进行处理。
2. targets = torch.Tensor(targets_array)：将目标数组 targets_array 转换为 PyTorch 的张量对象 targets，同样使用 torch.Tensor() 函数进行转换。
3. dataset = TensorDataset(inputs, targets)：使用转换后的输入特征张量 inputs 和目标张量 targets 创建了一个名为 dataset 的 PyTorch 数据集对象 TensorDataset。TensorDataset 可以用于在训练和验证过程中批量加载数据。
4. train_ds, val_ds = random_split(dataset, [228, 57])：使用 random_split() 函数将 dataset 数据集随机划分为训练集和验证集。参数 [228, 57] 表示划分比例，其中训练集占比 228/(228+57)，验证集占比 57/(228+57)。返回的 train_ds 和 val_ds 分别表示划分后的训练集和验证集。
5. batch_size = 128：定义了批量训练的批次大小，即每次从数据加载器中获取的样本数。
6. train_loader = DataLoader(train_ds, batch_size, shuffle=True)：创建了一个训练集的数据加载器 train_loader。数据加载器用于按照批次加载训练数据。train_ds 表示要加载的训练集数据，batch_size 表示每个批次的样本数，shuffle=True 表示在每个 epoch 开始时随机打乱数据顺序。
7. val_loader = DataLoader(val_ds, batch_size)：创建了一个验证集的数据加载器 val_loader。与训练集的数据加载器类似，用于按照批次加载验证数据。val_ds 表示要加载的验证集数据，batch_size 表示每个批次的样本数。

  通过以上步骤，您已经将转换后的数据集划分为训练集和验证集，并创建了相应的数据加载器，以便在模型训练过程中使用批量数据进行训练和验证。

5. 创建 PyTorch 模型

  现在，我们将使用 PyTorch 创建一个线性回归模型来预测汽车价格：

input_size = len(input_cols)
output_size = len(output_cols)

class CarsModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(input_size, output_size)                
        
    def forward(self, xb):
        out = self.linear(xb)                          
        return out
    
    def training_step(self, batch):
        inputs, targets = batch 
        # Generate predictions
        out = self(inputs)          
        # Calcuate loss
        loss = F.l1_loss(out, targets)                         
        return loss
    
    def validation_step(self, batch):
        inputs, targets = batch
        # Generate predictions
        out = self(inputs)
        # Calculate loss
        loss = F.l1_loss(out, targets)                          
        return {'val_loss': loss.detach()}
        
    def validation_epoch_end(self, outputs):
        batch_losses = [x['val_loss'] for x in outputs]
        epoch_loss = torch.stack(batch_losses).mean()  
        return {'val_loss': epoch_loss.item()}
    
    def epoch_end(self, epoch, result, num_epochs):
        # Print result every 20th epoch
        if (epoch+1) % 20 == 0 or epoch == num_epochs-1:
            print("Epoch [{}], val_loss: {:.4f}".format(epoch+1, result['val_loss']))

model = CarsModel()
list(model.parameters())

运行结果如下：

代码解释：
  这段代码定义了一个名为 CarsModel 的类，它是一个继承自 nn.Module 的神经网络模型。以下是对每行代码的详细解释：

1. input_size = len(input_cols)：通过使用 len(input_cols)，获取输入特征列表 input_cols 的长度，即输入特征的数量。len() 函数用于计算列表中元素的数量。
2. output_size = len(output_cols)：通过使用 len(output_cols)，获取输出列列表 output_cols 的长度，即输出列的数量。
3. class CarsModel(nn.Module):：定义了一个名为 CarsModel 的类，它继承自 nn.Module 类，表示这是一个神经网络模型。
4. def __init__(self):：定义了 CarsModel 类的构造函数。在构造函数中进行模型的初始化操作。
5. super().__init__()：调用父类 nn.Module 的构造函数，以确保正确地初始化模型。
6. self.linear = nn.Linear(input_size, output_size)：定义了模型中的线性层 self.linear，它是一个全连接层 (nn.Linear)，输入大小为 input_size，输出大小为 output_size。这一层用于将输入特征映射到输出列。
7. def forward(self, xb):：定义了模型的前向传播函数。xb 表示输入数据的批量，通过该函数将输入数据传递到模型中进行计算。
8. out = self.linear(xb)：在前向传播函数中，通过调用线性层 self.linear 将输入数据 xb 进行线性变换和激活函数操作，得到输出 out。
9. def training_step(self, batch):：定义了模型的训练步函数。batch 表示一个批次的训练数据。
10. inputs, targets = batch：从训练数据批次中获取输入特征和目标值。
11. out = self(inputs)：通过调用 self(inputs) 执行模型的前向传播，得到模型的预测结果。
12. loss = F.l1_loss(out, targets)：使用平均绝对误差损失函数 (F.l1_loss) 计算模型的训练损失。
13. def validation_step(self, batch):：定义了模型的验证步函数。batch 表示一个批次的验证数据。
14. inputs, targets = batch：从验证数据批次中获取输入特征和目标值。
15. out = self(inputs)：通过调用 self(inputs) 执行模型的前向传播，得到模型的预测结果。
16. loss = F.l1_loss(out, targets)：使用平均绝对误差损失函数 (F.l1_loss) 计算模型的验证损失。
17. def validation_epoch_end(self, outputs):：定义了模型的验证轮结束函数。outputs 是一个列表，包含每个验证步函数返回的损失。
18. batch_losses = [x['val_loss'] for x in outputs]：从输出列表中提取每个验证步函数返回的损失值。
19. epoch_loss = torch.stack(batch_losses).mean()：计算所有批次的平均损失，将每个批次的损失堆叠为张量，然后计算其均值。
20. return {'val_loss': epoch_loss.item()}：返回包含验证损失的字典。
21. def epoch_end(self, epoch, result, num_epochs):：定义了模型的轮结束函数。epoch 表示当前轮数，result 是包含验证损失的字典，num_epochs 表示总轮数。
22. (epoch+1) % 20 == 0 or epoch == num_epochs-1：判断是否是每 20 轮或最后一轮，用于控制输出的频率。
23. print("Epoch [{}], val_loss: {:.4f}".format(epoch+1, result['val_loss']))：打印当前轮数和验证损失。
24. model = CarsModel()：创建一个 CarsModel 类的实例，即实例化一个神经网络模型对象。
25. list(model.parameters())：返回模型中所有可学习参数的列表。这些参数将在模型训练过程中更新以优化模型的性能。

  在上述函数中，我使用了nn.Linear函数，它允许我们使用线性回归，现在我们可以使用F.l1_loss函数计算预测和损失，可以看到权重参数和偏置参数。通过这个模型，我们可以得到预测值，但仍需要进行训练。

6. 训练模型

  现在我们需要评估损失并查看损失有多少，并在进行训练后查看损失随着训练减少了多少：

# Eval algorithm
def evaluate(model, val_loader):
    outputs = [model.validation_step(batch) for batch in val_loader]
    return model.validation_epoch_end(outputs)

# Fitting algorithm
def fit(epochs, lr, model, train_loader, val_loader, opt_func=torch.optim.SGD):
    history = []
    optimizer = opt_func(model.parameters(), lr)
    for epoch in range(epochs):
        # Training Phase 
        for batch in train_loader:
            loss = model.training_step(batch)
            loss.backward()
            optimizer.step()
            optimizer.zero_grad()
        # Validation phase
        result = evaluate(model, val_loader)
        model.epoch_end(epoch, result, epochs)
        history.append(result)
    return history

# Check the initial value that val_loss have
result = evaluate(model, val_loader)
print(result)

运行结果如下：

代码解释：
  首先，这段代码定义了两个函数：evaluate 和 fit，用于评估和训练模型。然后，它调用了 evaluate 函数来计算模型在验证集上的初始性能。

1. def evaluate(model, val_loader):：定义了评估函数 evaluate，接受一个模型和一个验证数据加载器作为输入。
2. outputs = [model.validation_step(batch) for batch in val_loader]：通过迭代验证数据加载器中的每个批次，调用模型的 validation_step 函数，计算每个批次的验证损失，并将结果存储在列表 outputs 中。
3. return model.validation_epoch_end(outputs)：调用模型的 validation_epoch_end 函数，传递验证步的结果列表 outputs，该函数计算验证损失的平均值，并返回包含验证损失的字典。

  接下来，定义了训练函数 fit，用于执行模型的训练过程。

4. def fit(epochs, lr, model, train_loader, val_loader, opt_func=torch.optim.SGD):：定义了训练函数 fit，接受训练轮数 epochs、学习率 lr、模型 model、训练数据加载器 train_loader、验证数据加载器 val_loader 和优化器函数 opt_func（默认为随机梯度下降优化器 torch.optim.SGD）作为输入。

5. history = []：创建一个空列表 history，用于存储训练过程中的验证结果。

6. optimizer = opt_func(model.parameters(), lr)：使用给定的优化器函数 opt_func 和学习率 lr 初始化优化器 optimizer，将模型的可学习参数 model.parameters() 传递给优化器。

7. for epoch in range(epochs):：迭代每个训练轮数。

8. for batch in train_loader:：迭代训练数据加载器中的每个批次。

9. loss = model.training_step(batch)：调用模型的 training_step 函数，计算训练损失。

10. loss.backward()：执行反向传播，计算损失相对于模型参数的梯度。

11. optimizer.step()：使用优化器更新模型参数，优化模型的性能。

12. optimizer.zero_grad()：清零模型参数的梯度，以便下一轮的反向传播。

13. result = evaluate(model, val_loader)：在每个训练轮结束后，调用评估函数 evaluate，计算模型在验证集上的性能。

14. model.epoch_end(epoch, result, epochs)：在每个训练轮结束后，调用模型的 epoch_end 函数，打印当前轮数和验证损失。

15. history.append(result)：将验证结果添加到历史记录列表 history 中。

16. return history：返回历史记录列表。

  最后，检查模型在初始状态下的验证损失。

17. result = evaluate(model, val_loader)：调用 evaluate 函数，计算模型在验证集上的性能，并将结果存储在 result 中。
18. print(result)：打印初始验证损失，结果为 {'val_loss': 10644.4658203125}。

  这段代码定义了评估和训练函数，用于评估模型在验证集上的性能和训练模型的参数。它通过迭代训练数据的批次来更新模型参数，并在每个训练轮结束后计算模型在验证集上的损失。

# Start with the Fitting
epochs = 4000
lr = 1e-8
history1 = fit(epochs, lr, model, train_loader, val_loader)

运行结果如下：

代码解释：
  在这段代码中，我们定义了训练的轮数 epochs 为4000，学习率 lr 为 1e-8，并调用了 fit 函数来执行模型的训练过程。

1. history1 = fit(epochs, lr, model, train_loader, val_loader)：调用 fit 函数开始训练过程，并将训练轮数 epochs、学习率 lr、模型 model、训练数据加载器 train_loader 和验证数据加载器 val_loader 传递给函数。训练过程的结果将存储在 history1 列表中。

  在训练过程中，每经过 20 轮训练，或者是最后一轮训练时，会打印出当前轮数和验证损失。

2. model.epoch_end(epoch, result, epochs)：在每个训练轮结束后，调用模型的 epoch_end 函数，打印当前轮数和验证损失。

  这些结果表明随着训练的进行，模型在验证集上的性能逐渐提升，验证损失逐渐减小。最终的验证损失为33.0937，这是模型在最后一轮训练结束时在验证集上的性能评估。值得注意的是，验证损失的具体值取决于数据集的特性和模型的复杂性。较低的验证损失表示模型能够更好地拟合训练数据，并在未见过的验证数据上进行准确的预测。

# Train repeatdly until have a 'good' val_loss
epochs = 20
lr = 1e-9
history1 = fit(epochs, lr, model, train_loader, val_loader)

运行结果如下：

代码解释：
  在这段代码中，我们增加了训练的轮数 epochs 为 20，降低了学习率 lr 为 1e-9，并调用了 fit 函数来执行模型的训练过程。

1. history1 = fit(epochs, lr, model, train_loader, val_loader)：调用 fit 函数开始训练过程，并将训练轮数 epochs、学习率 lr、模型 model、训练数据加载器 train_loader 和验证数据加载器 val_loader 传递给函数。训练过程的结果将存储在 history1 列表中。

  在训练过程中，每经过 20 轮训练，或者是最后一轮训练时，会打印出当前轮数和验证损失。根据运行结果，我们可以看到在第 20 轮训练结束时，验证损失进一步降低至 2.1855。这表明通过增加训练轮数并降低学习率，模型在验证集上的性能有所改善，验证损失进一步减小。

7. 使用模型预测汽车价格

  最后，我们需要用特定的数据来测试模型：

# Prediction Algorithm
def predict_single(input, target, model):
    inputs = input.unsqueeze(0)
    predictions = model(inputs)                # fill this
    prediction = predictions[0].detach()
    print("Input:", input)
    print("Target:", target)
    print("Prediction:", prediction)

# Testing the model with some samples
input, target = val_ds[0]
predict_single(input, target, model)

运行结果如下：

代码解释：
  给上面代码中，我们有一个用于预测的算法 predict_single，它接受输入、目标和模型作为参数，并打印出输入、目标和预测结果。以下是代码的详细解释：

1. def predict_single(input, target, model): 定义了一个函数 predict_single，该函数接受输入、目标和模型作为参数。
2. inputs = input.unsqueeze(0): 将输入张量 input 进行维度扩展，使其成为一个大小为 (1, input_size) 的张量，以适应模型的输入要求。
3. predictions = model(inputs): 将扩展后的输入张量 inputs 输入到模型中进行预测。模型会生成预测值。
4. prediction = predictions[0].detach(): 从预测结果张量 predictions 中提取出第一个预测值，并使用 .detach() 方法将其从计算图中分离出来，以便打印和后续处理。
5. print("Input:", input): 打印输入张量的值，显示原始输入数据。
6. print("Target:", target): 打印目标张量的值，显示真实目标数据。
7. print("Prediction:", prediction): 打印预测值，显示模型对输入的预测结果。
8. input, target = val_ds[0]: 从验证数据集 val_ds 中获取第一个样本的输入和目标。
9. predict_single(input, target, model): 调用 predict_single 函数，传递输入、目标和模型作为参数，进行预测并打印结果。

  如您所见，预测非常接近预期目标，虽然不准确，但与预期相似。有了这个现在可以测试不同的结果，看看模型的性能：

input, target = val_ds[10]
predict_single(input, target, model)

运行结果如下：

代码解释：
  让我们详细解释上面的代码：

1. input, target = val_ds[10]：这行代码从验证数据集 val_ds 中获取索引为 10 的样本，并将其分配给 input 和 target 变量。这将使我们能够获取指定索引处的输入和目标数据。
2. predict_single(input, target, model)：这行代码调用了名为 predict_single 的函数，传递了 input、target 和 model 作为参数。这个函数用于对给定的输入样本进行预测并打印出输入、目标和预测结果。

  然后，函数 predict_single 将被执行，根据传入的参数进行预测并打印结果。

  以上为实验的所有内容，想要获取更多机器学习项目实战，记得关注博主！

   往期CSDN机器学习项目文章推荐：
  1.【机器学习/数据分析大项目】黑色星期五销售预测（详细报告+代码详解）
  2.【机器学习项目】使用机器学习算法预测航班价格（详细报告+代码详解）