深度学习实战—手机价格分类项目：从零到实战，手把手教你做AI项目

Yardon_Official

544人浏览 · 2026-03-26 22:45:09

Yardon_Official · 2026-03-26 22:45:09 发布

📖 导读：
这是一个完整的多分类项目，学完你能掌握：

数据处理全流程

神经网络搭建

模型训练与预测

优化技巧

每一行代码都有解释，涉及的每个知识点都会掰开揉碎讲清楚。

🗺️ 一、项目概览

1.1 这是什么项目？

目标：根据手机的各项参数（内存、存储、屏幕大小等），预测手机的价格档位（低/中/高/旗舰）。

这是一个经典的多分类问题，学完这个项目，你可以举一反三做：

房价预测（回归）
猫狗分类（图像分类）
垃圾邮件识别（二分类）
文本情感分析（NLP分类）

1.2 数据长什么样？

 battery_power,blue,clock_speed,...,price_range
 842,0,2.2,...,1
 1021,1,0.5,...,2

每一行是一部手机的数据，最后一列是价格档位（0=低档，1=中档，2=高档，3=旗舰）。

🔧 二、环境准备

2.1 需要安装的库

pip install pandas torch scikit-learn numpy

💡 代码解析：

pandas：数据处理，就像Excel的代码版

torch：PyTorch，深度学习框架

scikit-learn：机器学习瑞士军刀，啥都有

numpy：数值计算基础库

📚 三、数据处理（逐行解析）

全文的数据是按照： 文件 ——DataFrame —— Tensor张量 —— Dataset ——DataLoader

3.1 导包代码

import pandas as pd           # 数据处理
import torch                  # 深度学习框架
from sklearn.model_selection import train_test_split  # 数据划分
from sklearn.preprocessing import StandardScaler       # 标准化
from torch.utils.data import TensorDataset, DataLoader  # 数据加载
import numpy as np            # 数值计算
import torch.nn as nn         # 神经网络

💡 代码解析：

import pandas as pd：引入pandas库，给它起个别名叫pd（习惯用法）

from sklearn.model_selection import train_test_split：从sklearn引入数据划分函数

from sklearn.preprocessing import StandardScaler：引入标准化处理器

from torch.utils.data import TensorDataset, DataLoader：PyTorch的数据加载工具

import torch.nn as nn：PyTorch的神经网络模块，搭建网络用

3.2 数据读取

def create_dataset():
    # 读取CSV文件
    df = pd.read_csv("data/手机价格预测.csv", encoding="UTF-8")

💡 代码解析：

df：DataFrame的缩写，就是表格数据的容器，像Excel在代码里的表示

pd.read_csv()：读取CSV文件

encoding="UTF-8"：编码格式，中文数据必须指定

3.3 特征与标签分离

    # 拆分成特征(X)和目标值(y)
    x = df.iloc[:, :-1]  # 前n-1列是特征
    y = df.iloc[:, -1]   # 最后一列是目标

💡 代码解析：

df.iloc[]：按位置索引取值

[:, :-1]：所有行，所有列（除了最后一列）

[:, -1]：所有行，只有最后一列

为什么要这么做？

X是输入，y是输出

神经网络学习：X → 模型 → y

就像：给学生题目(X) → 老师教 → 学生学会 → 考试(y)

3.4 数据集划分

    # 划分训练集和测试集
    x_train, x_test, y_train, y_test = train_test_split(
        x, y, 
        test_size=0.2,      # 测试集占20%
        random_state=201     # 随机种子，保证结果可复现
    )

💡 代码解析：

train_test_split()：把数据分成训练集和测试集

test_size=0.2：20%用于测试，80%用于训练

random_state=201：随机种子，让每次划分结果一样

核心概念区分

x：代表输入数据（比如手机的内存、电池容量等参数）。

y：代表正确答案/目标（比如手机的价格等级）。

变量名全称含义作用

X_train 训练集特征 训练用的输入数据 给模型看：“这是手机参数，你学着找规律。”

y_train 训练集标签 训练用的正确答案 告诉模型：“刚才那些参数对应的真实价格是这些。”(模型通过对比自己的预测和 y_train 来修正误差)

X_test 测试集特征 考试用的输入数据 给模型看：“这是没见过的新手机参数，你预测一下价格。”

y_test 测试集标签 考试用的标准答案 用来打分：把模型的预测结果和 y_test 对比，计算准确率。(注意：模型在训练时绝对看不到 y_test)

变量名	全称	含义	作用
`X_train`	训练集特征	训练用的输入数据	给模型看：“这是手机参数，你学着找规律。”
`y_train`	训练集标签	训练用的正确答案	告诉模型：“刚才那些参数对应的真实价格是这些。”(模型通过对比自己的预测和 `y_train` 来修正误差)
`X_test`	测试集特征	考试用的输入数据	给模型看：“这是没见过的新手机参数，你预测一下价格。”
`y_test`	测试集标签	考试用的标准答案	用来打分：把模型的预测结果和 `y_test` 对比，计算准确率。(注意：模型在训练时绝对看不到 `y_test`)

3.5 特征标准化（关键优化！）

    # 标准化处理
    transformer = StandardScaler()
    
    # 用训练集拟合标准化器，然后转换训练集
    x_train = transformer.fit_transform(x_train)
    
    # 用同样的标准化器转换测试集
    x_test = transformer.transform(x_test)

💡 代码解析：

StandardScaler()：标准化处理器

fit_transform()：先学习数据分布，再转换（训练集用）

transform()：只转换，不学习（测试集用）

为什么要标准化？
假设手机数据：

电池容量：1000-6000mAh（数值大）

内存大小：2-16GB（数值小）

像素：12-108MP（数值中）

如果不标准化，大数值特征会主导学习，模型会"偏心"某个特征！

3.6 DataFrame转Tensor

    # DataFrame → PyTorch张量
    x_train = torch.tensor(x_train, dtype=torch.float32)
    x_test = torch.tensor(x_test, dtype=torch.float32)

    # 标签要转成int64（长整型）
    y_train = torch.tensor(y_train.values, dtype=torch.int64)
    y_test = torch.tensor(y_test.values, dtype=torch.int64)

💡 代码解析：

x_train.values：DataFrame转numpy数组（只取数据内容，其他的字段名称不需要）

torch.tensor()：转成PyTorch张量

dtype=torch.float32：32位浮点数，深度学习默认

dtype=torch.int64：64位整数，分类标签用这个

为什么要转Tensor？

PyTorch只能处理张量格式的数据

Tensor是PyTorch的核心数据结构

GPU加速也必须用Tensor

3.7 打包成Dataset

    # Tensor → Dataset
    train_dataset = TensorDataset(x_train, y_train)
    test_dataset = TensorDataset(x_test, y_test)

💡 代码解析：

TensorDataset：把特征和标签打包在一起

train_dataset[0]：返回(x_train[0], y_train[0])

3.8 返回必要信息

    # 特征个数
    feature_nums = x.shape[1]
    
    # 目标值类别数（去重后的数量）
    target_nums = len(np.unique(y))
    
    return train_dataset, test_dataset, feature_nums, target_nums

💡 代码解析：

x.shape[1]：取特征矩阵的列数

np.unique(y)：找出所有不重复的类别

len()：计算类别数量

3.9 完整代码

import pandas as pd           # 数据处理
import torch                  # 深度学习框架
from sklearn.model_selection import train_test_split  # 数据划分
from sklearn.preprocessing import StandardScaler       # 标准化
from torch.utils.data import TensorDataset, DataLoader  # 数据加载
import numpy as np            # 数值计算
import torch.nn as nn         # 神经网络
import os

# 1. 获取当前脚本 (__file__) 的绝对路径
script_dir = os.path.dirname(os.path.abspath(__file__))

# 2. 拼接 data 文件夹和文件名的路径
# os.path.join 会自动处理不同操作系统的路径分隔符 (/ 或 \)
file_path = os.path.join(script_dir, "data", "手机价格预测.csv")

def create_dataset():
    # 读取CSV文件
    df = pd.read_csv(file_path, encoding="UTF-8")
    # print(df.head())

    # 拆分成特征(X)和目标值(y)
    x = df.iloc[:, :-1]  # 前n-1列是特征
    y = df.iloc[:, -1]   # 最后一列是目标

     # 划分训练集和测试集
    x_train, x_test, y_train, y_test = train_test_split(
        x, y,
        test_size=0.2,      # 测试集占20%
        random_state=201     # 随机种子，保证结果可复现
    )

    # 标准化处理 - 这是优化版本才有的！
    transformer = StandardScaler()

    # 用训练集拟合标准化器，然后转换训练集
    x_train = transformer.fit_transform(x_train)

    # 用同样的标准化器转换测试集
    x_test = transformer.transform(x_test)

    # DataFrame → PyTorch张量
    x_train = torch.tensor(x_train, dtype=torch.float32)
    x_test = torch.tensor(x_test, dtype=torch.float32)

    # 标签要转成int64（长整型）
    y_train = torch.tensor(y_train.values, dtype=torch.int64)
    y_test = torch.tensor(y_test.values, dtype=torch.int64)

    # Tensor → Dataset
    train_dataset = TensorDataset(x_train, y_train)
    test_dataset = TensorDataset(x_test, y_test)

    # 特征个数
    feature_nums = x.shape[1]

    # 目标值类别数（去重后的数量）
    target_nums = len(np.unique(y))

    return train_dataset, test_dataset, feature_nums, target_nums

🏗️ 四、神经网络模型（逐行解析）

4.1 完整代码

# 2- 自定义网络结构
class PhonePriceModel(nn.Module):
    def __init__(self, feature_nums, target_nums):
        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.feature_nums = feature_nums
        self.target_nums = target_nums

        # 3- 搭建网络结构
        # 3.1- 第一层隐藏层
        # 注意：in_features需要和数据中特征个数完全一致
        self.linear1 = nn.Linear(in_features=self.feature_nums, out_features=512)
        self.dropout1 = nn.Dropout(p=0.3)

        # 3.2- 第二层隐藏层
        self.linear2 = nn.Linear(in_features=512, out_features=256)
        
        # 3.3- 输出层
        self.output = nn.Linear(in_features=256, out_features=self.target_nums)

    def forward(self, data):
        # 1- 经过第一层隐藏层
        # data = torch.relu(self.linear1(data))
        data = self.dropout1(torch.relu(self.linear1(data)))

        # 2- 经过第二层隐藏层
        data = torch.relu(self.linear2(data))

        # 3- 经过输出层得到结果
        # 为什么这里不明确的调用softmax激活函数？因为后续训练的时候会调用CrossEntropyLoss，里面自带softmax
        return self.output(data)

4.2 类的定义

class PhonePriceModel(nn.Module):
    def __init__(self, feature_nums, target_nums):
        # 1- 初始化父类
        super().__init__()

💡 代码解析：

class PhonePriceModel(nn.Module)：定义一个类，继承PyTorch的nn.Module基类

class：定义一个类

PhonePriceModel：类名，由你自己命名（这里表示"手机价格模型"）

(nn.Module)：继承PyTorch的神经网络基类，获得参数管理、前向传播等功能

def __init__(self, feature_nums, target_nums)：构造函数

__init__：Python的构造函数，创建对象时自动调用

self：当前对象的引用

feature_nums, target_nums：传入的两个参数（特征数量、目标类别数）

super().__init__()：必须调用！ 调用父类nn.Module的初始化，让模型具备完整的功能

super()：获取父类对象

.__init__()：调用父类的初始化方法

4.3 设置属性

        # 2- 设置属性值
        self.feature_nums = feature_nums
        self.target_nums = target_nums

💡 代码解析：

把传入的参数保存为实例属性，方便后面使用

self.feature_nums = feature_nums：保存特征数量

这个项目中，手机数据有21个特征（电池、内存、存储等）

self.target_nums = target_nums：保存目标类别数

这个项目中，价格档位有4个（0低档、1中档、2高档、3旗舰）

4.4 第一层隐藏层

        # 3- 搭建网络结构
        # 3.1- 第一层隐藏层
        # 注意：in_features需要和数据中特征个数完全一致
        self.linear1 = nn.Linear(in_features=self.feature_nums, out_features=512)
        self.dropout1 = nn.Dropout(p=0.3)

💡 代码解析：

self.linear1 = nn.Linear(in_features=self.feature_nums, out_features=512)：

创建第一个全连接层（也叫线性层）

nn.Linear：PyTorch中实现线性变换的类，数学公式是 y = Wx + b

W：权重矩阵（需要模型学习的参数）

b：偏置（需要模型学习的参数）

in_features=self.feature_nums：输入维度 = 21（手机有21个特征）

out_features=512：输出维度 = 512（第一层有512个神经元/节点）

self.dropout1 = nn.Dropout(p=0.3)：

创建Dropout层

p=0.3：每次训练时，随机丢弃30%的神经元

作用：防止过拟合（让模型不要"死记硬背"，而是"真学"）

4.5 第二层隐藏层

        # 3.2- 第二层隐藏层
        self.linear2 = nn.Linear(in_features=512, out_features=256)

💡 代码解析：

self.linear2 = nn.Linear(in_features=512, out_features=256)：

创建第二个全连接层

in_features=512：输入维度 = 512（承接第一层的输出）

out_features=256：输出维度 = 256（第二层有256个神经元）

维度必须对应：第一层输出512维 = 第二层输入512维

4.6 输出层

        # 3.3- 输出层
        self.output = nn.Linear(in_features=256, out_features=self.target_nums)

💡 代码解析：

self.output = nn.Linear(in_features=256, out_features=self.target_nums)：

创建输出层（分类头）

in_features=256：输入维度 = 256（承接第二层的输出）

out_features=self.target_nums：输出维度 = 4（对应4个价格档位）

为什么输出层没有激活函数？

因为后续使用CrossEntropyLoss（交叉熵损失函数）

这个损失函数内部自带softmax，会自动把输出转换成概率分布

4.7 前向传播 forward()

    def forward(self, data):
        # 1- 经过第一层隐藏层
        # data = torch.relu(self.linear1(data))
        data = self.dropout1(torch.relu(self.linear1(data)))

        # 2- 经过第二层隐藏层
        data = torch.relu(self.linear2(data))

        # 3- 经过输出层得到结果
        # 为什么这里不明确的调用softmax激活函数？因为后续训练的时候会调用CrossEntropyLoss，里面自带softmax
        return self.output(data)

💡 代码解析：

def forward(self, data)：前向传播函数，定义数据如何流动

forward：方法名，PyTorch会自动调用这个方法进行前向传播

self：当前模型对象

data：输入数据

第一层：data = self.dropout1(torch.relu(self.linear1(data)))

执行顺序（从内到外）：

self.linear1(data)：先经过线性变换（21维 → 512维）

torch.relu(...)：再经过ReLU激活函数（引入非线性）

self.dropout1(...)：最后经过Dropout（随机丢弃30%神经元）

第二层：data = torch.relu(self.linear2(data))

线性变换（512维 → 256维）+ ReLU激活

这里没有Dropout（一般只在部分层使用）

输出层：return self.output(data)

直接返回线性输出（256维 → 4维）

不经过激活函数，因为损失函数会处理

4.8 数据流动图示

📊 数据流动示意：

输入数据(21个特征：电池、内存、存储、屏幕...)
    ↓
[Linear1: 21→512]  ← W1权重矩阵 + b1偏置
    ↓
[ReLU激活函数]  ← 引入非线性
    ↓
[Dropout(p=0.3)] ← 随机丢弃30%神经元，防止过拟合
    ↓
[Linear2: 512→256] ← W2权重矩阵 + b2偏置
    ↓
[ReLU激活函数]
    ↓
[Output: 256→4] ← W3权重矩阵 + b3偏置
    ↓
返回4个分类分数（logits）
    ↓
CrossEntropyLoss(内部包含softmax) → 计算损失

🚀 五、模型训练（逐行解析）

5.1 DataLoader

def train_model(train_dataset, feature_nums, target_nums):
    # 设置随机种子，让数据划分固定下来
    torch.manual_seed(201)
    
    # 创建DataLoader
    dataloader = DataLoader(
        dataset=train_dataset,
        batch_size=8,     # 每批8条数据
        shuffle=True       # 打乱数据
    )

💡 代码解析：

torch.manual_seed(201)：设置随机种子，保证结果可复现

DataLoader：数据加载器

batch_size=8：每次送8条数据到GPU（不能一次送太多，会显存不足）——批次

shuffle=True：打乱数据顺序，防止模型记住数据的顺序

5.2 创建模型

    # 创建网络模型实例对象
    model = PhonePriceModel(feature_nums, target_nums)

💡 代码解析：

创建模型对象，传入特征数量(21)和目标类别数(4)

5.3 损失函数

    # 创建损失函数对象：多分类问题需要使用交叉熵损失函数
    loss = nn.CrossEntropyLoss()

💡 代码解析：

nn.CrossEntropyLoss()：交叉熵损失函数

多分类问题必用

内部自带softmax，会自动把logits转换成概率分布

衡量预测概率分布和真实分布的差异

5.4 优化器

    # 创建优化器对象
    # optimzer = torch.optim.SGD(params=model.parameters(), lr=1e-3)
    optimzer = torch.optim.Adam(params=model.parameters(), lr=1e-4, betas=(0.9, 0.99))

💡 代码解析：

torch.optim.Adam：Adam优化器（推荐使用）

params=model.parameters()：告诉优化器要优化哪些参数（模型的所有w和b）

lr=1e-4：学习率，1×10⁻⁴ = 0.0001（Adam适合用较小的学习率）

betas=(0.9, 0.99)：动量参数，控制梯度更新的平滑程度

注释掉的SGD是另一种优化器，但Adam通常收敛更快

5.5 训练循环

    # 循环训练
    epochs = 50  # 对总样本，总共训练多少个轮次
    model.train()   # 切换模式为训练模式。也就是允许神经网络随机失活

    for epoch in range(epochs):
        # 外层循环控制轮次

        # 记录损失值的变化过程
        total_loss_value = 0.0  # 每个轮次中总的损失值
        total_sample_num = 0    # 每个轮次中已经训练的样本条数

        for x, y in dataloader:
            # x样本中的输入数据；y样本中的真实值
            # 内层循环控制批次

            # 5.1- 前向传播
            pred_y = model(x)

            # 5.2- 计算损失值
            loss_value = loss(pred_y, y)

            # 记录损失值
            total_loss_value += loss_value.item()
            total_sample_num += len(x)

            # 5.3- 固定代码
            # 梯度清零：默认会对梯度值进行累积
            optimzer.zero_grad()
            # 反向传播：注意只有标量张量能进行反向传播
            loss_value.sum().backward()
            # 更新参数：也就是更新w和b
            optimzer.step()

        print(f"第{epoch + 1}次，总的平均损失是：{total_loss_value / total_sample_num}")

💡 代码解析：

model.train()：切换为训练模式（让Dropout生效）

epochs = 50：训练50轮（每轮都看一遍所有数据）

for epoch in range(epochs)：外层循环，控制轮次

for x, y in dataloader：内层循环，按批次处理数据

pred_y = model(x)：前向传播，让数据穿过网络得到预测结果

loss(pred_y, y)：计算损失，比较预测值和真实值的差异

optimzer.zero_grad()：梯度清零（重要！如果不清零，梯度会累积）

loss_value.sum().backward()：反向传播，自动计算每个参数的梯度

optimzer.step()：更新参数，根据梯度调整w和b

5.6 保存模型

    # 保存训练好的模型
    torch.save(model.state_dict(), "model/phone_price_model.pkl")

💡 代码解析：

model.state_dict()：获取模型的所有参数（w和b的数值）

torch.save(...)：保存到文件

📊 六、模型预测（逐行解析）

6.1 加载数据和模型

def predict_model(test_dataset, feature_nums, target_nums):
    # 创建数据加载器
    # 注意：模型预测的时候shuffle要设置为False，也就是不让数据打散，为了让预测结果稳定
    dataloader = DataLoader(dataset=test_dataset, batch_size=8, shuffle=False)

    # 创建算法模型
    model = PhonePriceModel(feature_nums, target_nums)

    # 加载训练好的模型
    model.load_state_dict(torch.load("model/phone_price_model.pkl"))

💡 代码解析：

shuffle=False：预测时不要打乱数据，保证结果稳定

model.load_state_dict(...)：加载训练好的参数

6.2 预测与评估

    # 预测
    model.eval()    # 切换为预测模式。禁止随机失活Dropout
    correct_cnt = 0 # 预测正确的总样本条数

    for x, y in dataloader:
        # 4.1- 前向传播：预测
        pred_y = model(x)

        """
        1- pred_y：只是输出层中线性求和的结果，并没有经过softmax的处理
        2- 可以手动调用softmax，将线性结果处理成概率值。torch.softmax(pred_y,dim=-1)
        """
        print(f"pred_y-->{pred_y}")
        print(f"pred_y经过softmax的处理-->{torch.softmax(pred_y,dim=-1)}")

        # 4.2- 获得预测概率值最高的索引。实际就是获得了预测目标值的类别
        pred_id = torch.argmax(pred_y, dim=-1)
        print(f"argmax的结果-->{pred_id}")

        # 4.3- 统计预测正确的数据条数
        print(f"真实值-->{y}")
        print(f"判断结果-->{(pred_id==y)}")
        correct_cnt = correct_cnt + (pred_id == y).sum()

    # 5- 计算准确率
    acc_rate = correct_cnt / len(test_dataset)
    print(f"预测的准确率是：{acc_rate}，预测正确的样本条数：{correct_cnt}，预测的总样本条数：{len(test_dataset)}")

💡 代码解析：

model.eval()：切换为评估模式（Dropout不生效）

pred_y = model(x)：前向传播，得到预测结果

torch.softmax(pred_y, dim=-1)：手动转成概率（可选）

torch.argmax(pred_y, dim=-1)：取最大值索引，得到预测的类别

correct_cnt + (pred_id == y).sum()：统计预测正确的数量

6.3 argmax详解

# argmax示意图

pred_y = [2.1, 4.5, 1.2, 0.8]  # 4个类别的分数
         [低,   中,   高,   旗舰]  # 价格档位
          0     1     2     3     # 索引

argmax = 1  # 最大值是4.5，在索引1的位置

# 所以预测结果是"中档"

🔬 七、优化技巧对比

7.1 优化前后对比

项目	优化前	优化后	为什么
标准化	❌ 没有	✅ 有	加速收敛
优化器	SGD	Adam	更快更稳
学习率	1e-3	1e-4	Adam用较小学习率
Dropout	❌ 没有	✅ p=0.3	防止过拟合

📝 八、核心知识点总结

8.1 机器学习核心概念

概念	解释	在项目中的体现
特征	输入数据	手机参数（电池、内存…）
标签	要预测的东西	价格档位（0/1/2/3）
训练集	学习用的数据	80%数据
测试集	检验的数据	20%数据
过拟合	记住了但不会做	用Dropout解决

8.2 深度学习核心概念

概念	解释
张量(Tensor)	多维数组，PyTorch的数据格式
全连接层	每神经元连接所有输入
激活函数	引入非线性，ReLU最常用
反向传播	自动计算梯度的算法
优化器	更新参数的算法，Adam推荐

8.3 训练流程图

┌─────────────────────────────────────────┐
│           数据准备阶段                      │
│  CSV → DataFrame → 划分 → 标准化 → Tensor  │
└─────────────────┬───────────────────────┘
                  ↓
┌─────────────────────────────────────────┐
│           模型构建阶段                      │
│   定义网络结构 → 创建模型实例               │
└─────────────────┬───────────────────────┘
                  ↓
┌─────────────────────────────────────────┐
│           训练循环（核心！）                │
│  ┌─────────────────────────────────┐    │
│  │ for batch in dataloader:        │    │
│  │     前向传播 → 计算损失           │    │
│  │     梯度清零 → 反向传播 → 更新参数 │    │
│  └─────────────────────────────────┘    │
└─────────────────┬───────────────────────┘
                  ↓
┌─────────────────────────────────────────┐
│           模型预测阶段                      │
│   加载模型 → 前向传播 → argmax → 准确率   │
└─────────────────────────────────────────┘

🎯 九、如何自己手搓这类项目

9.1 项目模板（背下来！）

# ===== 1. 数据处理 =====
def load_data():
    df = pd.read_csv("data.csv")
    x = df.iloc[:, :-1]
    y = df.iloc[:, -1]
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
    
    # 标准化（如果是数值数据）
    scaler = StandardScaler()
    x_train = scaler.fit_transform(x_train)
    x_test = scaler.transform(x_test)
    
    # 转Tensor
    x_train = torch.tensor(x_train, dtype=torch.float32)
    ...
    return train_dataset, test_dataset

# ===== 2. 模型定义 =====
class MyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.layers = nn.Sequential(
            nn.Linear(in_features, 128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, out_features)
        )
    
    def forward(self, x):
        return self.layers(x)

# ===== 3. 训练 =====
def train(model, dataloader):
    loss_fn = nn.CrossEntropyLoss()  # 分类
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
    
    for epoch in range(50):
        for x, y in dataloader:
            pred = model(x)
            loss = loss_fn(pred, y)
            
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

# ===== 4. 预测 =====
def predict(model, test_data):
    model.eval()
    with torch.no_grad():
        pred = model(test_data)
        return torch.argmax(pred, dim=-1)

9.2 举一反三

任务	改哪里
房价预测	损失函数→MSE，输出层→1个神经元
图像分类	用CNN (Conv2d)
文本分类	用Embedding + RNN/Transformer
目标检测	用YOLO/Faster RCNN

💼 十、AI大模型开发岗位要求

10.1 岗位技能树

AI大模型开发工程师
├── 基础能力
│   ├── Python编程 ⭐⭐⭐⭐⭐
│   ├── 数据结构与算法 ⭐⭐⭐⭐
│   └── 机器学习基础 ⭐⭐⭐⭐⭐
│
├── 深度学习
│   ├── PyTorch/TensorFlow ⭐⭐⭐⭐⭐
│   ├── CNN/RNN/Transformer ⭐⭐⭐⭐⭐
│   └── 模型训练调优 ⭐⭐⭐⭐
│
├── 大模型相关
│   ├── LLM原理 (GPT/BERT/LLaMA) ⭐⭐⭐⭐
│   ├── Prompt Engineering ⭐⭐⭐⭐
│   ├── Fine-tuning ⭐⭐⭐⭐⭐
│   └── RAG/Agent ⭐⭐⭐⭐
│
└── 工程能力
    ├── Git版本控制 ⭐⭐⭐⭐
    ├── Docker容器 ⭐⭐⭐⭐
    └── Linux基础 ⭐⭐⭐

10.2 能力要求详解

必须精通（⭐⭐⭐⭐⭐）

技能	要求	达标表现
Python	能写、能debug	能独立完成数据处理和模型搭建
PyTorch	熟练	能手写网络结构，理解训练流程
机器学习	理解原理	能解释过拟合，正则化、梯度下降
深度学习	理解原理	能解释CNN/RNN/Attention