qidao123.com技术社区-IT企服评测·应用市场»论坛 › 软件与程序人生 › DevOps与敏捷开发 › Python练习营打卡——DAY33（2025.5.22）

Python练习营打卡——DAY33（2025.5.22）

[复制链接]
发表于 2025-5-23 21:50:56 | 显示全部楼层 |阅读模式
目录
简单的神经网络
一、PyTorch的安装
二、准备工作
三、数据的准备
四、模型架构界说
五、模型练习（CPU版本）
1. 界说损失函数和优化器
2. 开始循环练习
3. 可视化结果
六、通俗解释
1. 环境安装（相称于买锅碗瓢盆）​​
2. 数据准备（洗菜切菜）​​
3. 模型界说（设计菜谱）​​
​​4. 练习过程（炒菜实操）​​
​​5. 评估与可视化（考试和总结）​​
6. ​​通俗总结​​
7. 类比问答​​

简单的神经网络

默认各人已经有一定的神经网络基础，该部门已经在复试班的深度学习部门先容完毕，如果没有，你需要自行了解下MLP的概念。
你需要知道

  • 梯度降落的头脑
  • 激活函数的作用
  • 损失函数的作用
  • 优化器
  • 神经网络的概念
神经网络由于内部比力灵活，所以封装的比力浅，可以对模型做非常多的改进，而不像机器学习三行代码固定。
一、PyTorch的安装

我们后续完成深度学习项目中，重要使用的包为pytorch，所以需要安装，你需要去设置一个新的环境。
未来在复现具体项目时候，新环境定名最好是python版本_pytorch版本_cuda版本，比方 py3.10_pytorch2.0_cuda12.2 ,由于复杂项目对运行环境有要求，所以需要安装对应版本的包。
我们目前重要不消这么严酷，先创建一个定名为DL的新环境即可,也可以沿用之前的环境
  1. conda create -n DL python=3.8
  2. conda env list
  3. conda activate DL
  4. conda install jupyter （如果conda无法安装jupyter就参考环境配置文档的pip安装方法）
  5. pip insatll scikit-learn
  6. 然后对着下列教程安装pytorch
复制代码
深度学习重要是简单的并行盘算，所以gpu上风更大，简单的盘算cpu发挥不出来他的价值，我们之前说过显卡和cpu的区别：

  • cpu是1个博士生，能够完成复杂的盘算，串行能力强。
  • gpu是100个小学生，能够完成简单的盘算，人多盘算的快。
这里的gpu指的是英伟达的显卡，它支持cuda可以提高并行盘算的能力。
如果你是amd的显卡、苹果的电脑，那样就不需要安装cuda了，直接安装pytorch-gpu版本即可。cuda只支持nvidia的显卡。
安装教程
或者去b站任意搜个pytorch安装视频。

  • 怕麻烦直接安装cpu版本的pytorch，跑通了用云服务器版本的pytorch-gpu
  • gpu的pytorch还需要额外安装cuda cudnn组件
二、准备工作

可以在你电脑的cmd中输入nvidia-smi来查看下显卡信息

此中最重要的2个信息，分别是：

  • 显卡目前驱动下最高支持的cuda版本，12.7
  • 显存大小，12288 MiB ÷ 1024 = 12
PS:之所以输入这个命令，可以弹出这些信息，是由于为系统精确安装了 NVIDIA 显卡驱动步伐，并且相关路径被添加到了环境变量中。如果你不是英伟达的显卡，自然无法使用这个命令。
  1. import torch
  2. torch.cuda
复制代码
  1. <module 'torch.cuda' from 'd:\\Anaconda\\envs\\yolov5\\lib\\site-packages\\torch\\cuda\\__init__.py'>
复制代码
  1. import torch
  3. # 检查CUDA是否可用
  4. if torch.cuda.is_available():
  5.     print("CUDA可用！")
  6.     # 获取可用的CUDA设备数量
  7.     device_count = torch.cuda.device_count()
  8.     print(f"可用的CUDA设备数量: {device_count}")
  9.     # 获取当前使用的CUDA设备索引
  10.     current_device = torch.cuda.current_device()
  11.     print(f"当前使用的CUDA设备索引: {current_device}")
  12.     # 获取当前CUDA设备的名称
  13.     device_name = torch.cuda.get_device_name(current_device)
  14.     print(f"当前CUDA设备的名称: {device_name}")
  15.     # 获取CUDA版本
  16.     cuda_version = torch.version.cuda
  17.     print(f"CUDA版本: {cuda_version}")
  18. else:
  19.     print("CUDA不可用。")
复制代码
  1. CUDA可用！
  2. 可用的CUDA设备数量: 1
  3. 当前使用的CUDA设备索引: 0
  4. 当前CUDA设备的名称: NVIDIA GeForce RTX 3080 Ti
  5. CUDA版本: 11.1
复制代码
这里的cuda版本是实际安装的cuda驱动的版本，需要小于显卡所支持的最高版本
上述这段代码，可以以后不断复用，查抄是否有pytorch及cuda相关信息，我们今天先用cpu练习，不必在意，有没有cuda不影响。
三、数据的准备

    预处理补充：
  注意事项：
  （1）分类任务中，若标签是整数（如 0/1/2 类别），需转为long类型（对应 PyTorch 的torch.long），否则交织熵损失函数会报错。
  （2）回归任务中，标签需转为float类型（如torch.float32）。
  1. # 仍然用4特征，3分类的鸢尾花数据集作为我们今天的数据集
  2. from sklearn.datasets import load_iris
  3. from sklearn.model_selection import train_test_split
  4. import numpy as np
  6. # 加载鸢尾花数据集
  7. iris = load_iris()
  8. X = iris.data  # 特征数据
  9. y = iris.target  # 标签数据
  10. # 划分训练集和测试集
  11. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
  13. # 打印下尺寸
  14. print(X_train.shape)
  15. print(y_train.shape)
  16. print(X_test.shape)
  17. print(y_test.shape)
复制代码
  1. (120, 4)
  2. (120,)
  3. (30, 4)
  4. (30,)
复制代码
  1. # 归一化数据，神经网络对于输入数据的尺寸敏感，归一化是最常见的处理方式
  2. from sklearn.preprocessing import MinMaxScaler
  3. scaler = MinMaxScaler()
  4. X_train = scaler.fit_transform(X_train)
  5. X_test = scaler.transform(X_test) #确保训练集和测试集是相同的缩放
复制代码
  1. # 将数据转换为 PyTorch 张量，因为 PyTorch 使用张量进行训练
  2. # y_train和y_test是整数，所以需要转化为long类型，如果是float32，会输出1.0 0.0
  3. X_train = torch.FloatTensor(X_train)
  4. y_train = torch.LongTensor(y_train)
  5. X_test = torch.FloatTensor(X_test)
  6. y_test = torch.LongTensor(y_test)
复制代码
四、模型架构界说

界说一个简单的全连接神经网络模型，包罗一个输入层、一个隐藏层和一个输出层。
界说层数+界说前向流传顺序
  1. import torch
  2. import torch.nn as nn
  3. import torch.optim as optim
复制代码
  1. class MLP(nn.Module): # 定义一个多层感知机（MLP）模型，继承父类nn.Module
  2.     def __init__(self): # 初始化函数
  3.         super(MLP, self).__init__() # 调用父类的初始化函数
  4. # 前三行是八股文，后面的是自定义的
  6.         self.fc1 = nn.Linear(4, 10)  # 输入层到隐藏层
  7.         self.relu = nn.ReLU()
  8.         self.fc2 = nn.Linear(10, 3)  # 隐藏层到输出层
  9. # 输出层不需要激活函数，因为后面会用到交叉熵函数cross_entropy，交叉熵函数内部有softmax函数，会把输出转化为概率
  11.     def forward(self, x):
  12.         out = self.fc1(x)
  13.         out = self.relu(out)
  14.         out = self.fc2(out)
  15.         return out
  17. # 实例化模型
  18. model = MLP()
复制代码
其实模型层的写法有很多，relu也可以不写，在背面前向流传的时候盘算下即可，由于relu其实不算一个层，只是个盘算而已。
  1.     # def forward(self,x): #前向传播
  2.     #     x=torch.relu(self.fc1(x)) #激活函数
  3.     #     x=self.fc2(x) #输出层不需要激活函数，因为后面会用到交叉熵函数cross_entropy
  4.     #     return x
复制代码
五、模型练习（CPU版本）

1. 界说损失函数和优化器

  1. # 分类问题使用交叉熵损失函数
  2. criterion = nn.CrossEntropyLoss()
  4. # 使用随机梯度下降优化器
  5. optimizer = optim.SGD(model.parameters(), lr=0.01)
  7. # # 使用自适应学习率的化器
  8. # optimizer = optim.Adam(model.parameters(), lr=0.001)
复制代码
2. 开始循环练习

实际上在练习的时候，可以同时观察每个epoch练习完后测试集的表现：测试集的loss和准确度
  1. # 训练模型
  2. num_epochs = 20000 # 训练的轮数
  4. # 用于存储每个 epoch 的损失值
  5. losses = []
  7. for epoch in range(num_epochs): # range是从0开始，所以epoch是从0开始
  8.     # 前向传播
  9.     outputs = model.forward(X_train)   # 显式调用forward函数
  10.     # outputs = model(X_train)  # 常见写法隐式调用forward函数，其实是用了model类的__call__方法
  11.     loss = criterion(outputs, y_train) # output是模型预测值，y_train是真实标签
  13.     # 反向传播和优化
  14.     optimizer.zero_grad() #梯度清零，因为PyTorch会累积梯度，所以每次迭代需要清零，梯度累计是那种小的bitchsize模拟大的bitchsize
  15.     loss.backward() # 反向传播计算梯度
  16.     optimizer.step() # 更新参数
  18.     # 记录损失值
  19.     losses.append(loss.item())
  21.     # 打印训练信息
  22.     if (epoch + 1) % 100 == 0: # range是从0开始，所以epoch+1是从当前epoch开始，每100个epoch打印一次
  23.         print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
复制代码
  1. 输出结果：
复制代码
  1. Epoch [100/20000], Loss: 1.0730
  2. Epoch [200/20000], Loss: 1.0258
  3. Epoch [300/20000], Loss: 0.9757
  4. Epoch [400/20000], Loss: 0.9200
  5. Epoch [500/20000], Loss: 0.8577
  6. Epoch [600/20000], Loss: 0.7908
  7. Epoch [700/20000], Loss: 0.7247
  8. Epoch [800/20000], Loss: 0.6639
  9. Epoch [900/20000], Loss: 0.6109
  10. Epoch [1000/20000], Loss: 0.5661
  11. Epoch [1100/20000], Loss: 0.5285
  12. Epoch [1200/20000], Loss: 0.4967
  13. Epoch [1300/20000], Loss: 0.4695
  14. Epoch [1400/20000], Loss: 0.4456
  15. Epoch [1500/20000], Loss: 0.4244
  16. Epoch [1600/20000], Loss: 0.4052
  17. Epoch [1700/20000], Loss: 0.3877
  18. Epoch [1800/20000], Loss: 0.3715
  19. Epoch [1900/20000], Loss: 0.3564
  20. Epoch [2000/20000], Loss: 0.3423
  21. Epoch [2100/20000], Loss: 0.3290
  22. Epoch [2200/20000], Loss: 0.3165
  23. Epoch [2300/20000], Loss: 0.3046
  24. Epoch [2400/20000], Loss: 0.2935
  25. Epoch [2500/20000], Loss: 0.2829
  26. Epoch [2600/20000], Loss: 0.2729
  27. Epoch [2700/20000], Loss: 0.2635
  28. Epoch [2800/20000], Loss: 0.2545
  29. Epoch [2900/20000], Loss: 0.2461
  30. Epoch [3000/20000], Loss: 0.2381
  31. Epoch [3100/20000], Loss: 0.2306
  32. Epoch [3200/20000], Loss: 0.2235
  33. Epoch [3300/20000], Loss: 0.2168
  34. Epoch [3400/20000], Loss: 0.2104
  35. Epoch [3500/20000], Loss: 0.2044
  36. Epoch [3600/20000], Loss: 0.1987
  37. Epoch [3700/20000], Loss: 0.1933
  38. Epoch [3800/20000], Loss: 0.1882
  39. Epoch [3900/20000], Loss: 0.1833
  40. Epoch [4000/20000], Loss: 0.1787
  41. Epoch [4100/20000], Loss: 0.1744
  42. Epoch [4200/20000], Loss: 0.1702
  43. Epoch [4300/20000], Loss: 0.1663
  44. Epoch [4400/20000], Loss: 0.1625
  45. Epoch [4500/20000], Loss: 0.1590
  46. Epoch [4600/20000], Loss: 0.1556
  47. Epoch [4700/20000], Loss: 0.1523
  48. Epoch [4800/20000], Loss: 0.1492
  49. Epoch [4900/20000], Loss: 0.1463
  50. Epoch [5000/20000], Loss: 0.1435
  51. Epoch [5100/20000], Loss: 0.1408
  52. Epoch [5200/20000], Loss: 0.1382
  53. Epoch [5300/20000], Loss: 0.1358
  54. Epoch [5400/20000], Loss: 0.1334
  55. Epoch [5500/20000], Loss: 0.1312
  56. Epoch [5600/20000], Loss: 0.1290
  57. Epoch [5700/20000], Loss: 0.1269
  58. Epoch [5800/20000], Loss: 0.1249
  59. Epoch [5900/20000], Loss: 0.1230
  60. Epoch [6000/20000], Loss: 0.1212
  61. Epoch [6100/20000], Loss: 0.1194
  62. Epoch [6200/20000], Loss: 0.1177
  63. Epoch [6300/20000], Loss: 0.1161
  64. Epoch [6400/20000], Loss: 0.1145
  65. Epoch [6500/20000], Loss: 0.1130
  66. Epoch [6600/20000], Loss: 0.1116
  67. Epoch [6700/20000], Loss: 0.1102
  68. Epoch [6800/20000], Loss: 0.1088
  69. Epoch [6900/20000], Loss: 0.1075
  70. Epoch [7000/20000], Loss: 0.1062
  71. Epoch [7100/20000], Loss: 0.1050
  72. Epoch [7200/20000], Loss: 0.1038
  73. Epoch [7300/20000], Loss: 0.1027
  74. Epoch [7400/20000], Loss: 0.1016
  75. Epoch [7500/20000], Loss: 0.1005
  76. Epoch [7600/20000], Loss: 0.0995
  77. Epoch [7700/20000], Loss: 0.0985
  78. Epoch [7800/20000], Loss: 0.0975
  79. Epoch [7900/20000], Loss: 0.0966
  80. Epoch [8000/20000], Loss: 0.0957
  81. Epoch [8100/20000], Loss: 0.0948
  82. Epoch [8200/20000], Loss: 0.0940
  83. Epoch [8300/20000], Loss: 0.0932
  84. Epoch [8400/20000], Loss: 0.0924
  85. Epoch [8500/20000], Loss: 0.0916
  86. Epoch [8600/20000], Loss: 0.0908
  87. Epoch [8700/20000], Loss: 0.0901
  88. Epoch [8800/20000], Loss: 0.0894
  89. Epoch [8900/20000], Loss: 0.0887
  90. Epoch [9000/20000], Loss: 0.0880
  91. Epoch [9100/20000], Loss: 0.0874
  92. Epoch [9200/20000], Loss: 0.0867
  93. Epoch [9300/20000], Loss: 0.0861
  94. Epoch [9400/20000], Loss: 0.0855
  95. Epoch [9500/20000], Loss: 0.0849
  96. Epoch [9600/20000], Loss: 0.0844
  97. Epoch [9700/20000], Loss: 0.0838
  98. Epoch [9800/20000], Loss: 0.0833
  99. Epoch [9900/20000], Loss: 0.0827
  100. Epoch [10000/20000], Loss: 0.0822
  101. Epoch [10100/20000], Loss: 0.0817
  102. Epoch [10200/20000], Loss: 0.0812
  103. Epoch [10300/20000], Loss: 0.0808
  104. Epoch [10400/20000], Loss: 0.0803
  105. Epoch [10500/20000], Loss: 0.0798
  106. Epoch [10600/20000], Loss: 0.0794
  107. Epoch [10700/20000], Loss: 0.0790
  108. Epoch [10800/20000], Loss: 0.0785
  109. Epoch [10900/20000], Loss: 0.0781
  110. Epoch [11000/20000], Loss: 0.0777
  111. Epoch [11100/20000], Loss: 0.0773
  112. Epoch [11200/20000], Loss: 0.0769
  113. Epoch [11300/20000], Loss: 0.0766
  114. Epoch [11400/20000], Loss: 0.0762
  115. Epoch [11500/20000], Loss: 0.0758
  116. Epoch [11600/20000], Loss: 0.0755
  117. Epoch [11700/20000], Loss: 0.0751
  118. Epoch [11800/20000], Loss: 0.0748
  119. Epoch [11900/20000], Loss: 0.0745
  120. Epoch [12000/20000], Loss: 0.0741
  121. Epoch [12100/20000], Loss: 0.0738
  122. Epoch [12200/20000], Loss: 0.0735
  123. Epoch [12300/20000], Loss: 0.0732
  124. Epoch [12400/20000], Loss: 0.0729
  125. Epoch [12500/20000], Loss: 0.0726
  126. Epoch [12600/20000], Loss: 0.0723
  127. Epoch [12700/20000], Loss: 0.0721
  128. Epoch [12800/20000], Loss: 0.0718
  129. Epoch [12900/20000], Loss: 0.0715
  130. Epoch [13000/20000], Loss: 0.0712
  131. Epoch [13100/20000], Loss: 0.0710
  132. Epoch [13200/20000], Loss: 0.0707
  133. Epoch [13300/20000], Loss: 0.0705
  134. Epoch [13400/20000], Loss: 0.0702
  135. Epoch [13500/20000], Loss: 0.0700
  136. Epoch [13600/20000], Loss: 0.0698
  137. Epoch [13700/20000], Loss: 0.0695
  138. Epoch [13800/20000], Loss: 0.0693
  139. Epoch [13900/20000], Loss: 0.0691
  140. Epoch [14000/20000], Loss: 0.0688
  141. Epoch [14100/20000], Loss: 0.0686
  142. Epoch [14200/20000], Loss: 0.0684
  143. Epoch [14300/20000], Loss: 0.0682
  144. Epoch [14400/20000], Loss: 0.0680
  145. Epoch [14500/20000], Loss: 0.0678
  146. Epoch [14600/20000], Loss: 0.0676
  147. Epoch [14700/20000], Loss: 0.0674
  148. Epoch [14800/20000], Loss: 0.0672
  149. Epoch [14900/20000], Loss: 0.0670
  150. Epoch [15000/20000], Loss: 0.0668
  151. Epoch [15100/20000], Loss: 0.0667
  152. Epoch [15200/20000], Loss: 0.0665
  153. Epoch [15300/20000], Loss: 0.0663
  154. Epoch [15400/20000], Loss: 0.0661
  155. Epoch [15500/20000], Loss: 0.0659
  156. Epoch [15600/20000], Loss: 0.0658
  157. Epoch [15700/20000], Loss: 0.0656
  158. Epoch [15800/20000], Loss: 0.0654
  159. Epoch [15900/20000], Loss: 0.0653
  160. Epoch [16000/20000], Loss: 0.0651
  161. Epoch [16100/20000], Loss: 0.0650
  162. Epoch [16200/20000], Loss: 0.0648
  163. Epoch [16300/20000], Loss: 0.0647
  164. Epoch [16400/20000], Loss: 0.0645
  165. Epoch [16500/20000], Loss: 0.0644
  166. Epoch [16600/20000], Loss: 0.0642
  167. Epoch [16700/20000], Loss: 0.0641
  168. Epoch [16800/20000], Loss: 0.0639
  169. Epoch [16900/20000], Loss: 0.0638
  170. Epoch [17000/20000], Loss: 0.0637
  171. Epoch [17100/20000], Loss: 0.0635
  172. Epoch [17200/20000], Loss: 0.0634
  173. Epoch [17300/20000], Loss: 0.0633
  174. Epoch [17400/20000], Loss: 0.0631
  175. Epoch [17500/20000], Loss: 0.0630
  176. Epoch [17600/20000], Loss: 0.0629
  177. Epoch [17700/20000], Loss: 0.0627
  178. Epoch [17800/20000], Loss: 0.0626
  179. Epoch [17900/20000], Loss: 0.0625
  180. Epoch [18000/20000], Loss: 0.0624
  181. Epoch [18100/20000], Loss: 0.0623
  182. Epoch [18200/20000], Loss: 0.0621
  183. Epoch [18300/20000], Loss: 0.0620
  184. Epoch [18400/20000], Loss: 0.0619
  185. Epoch [18500/20000], Loss: 0.0618
  186. Epoch [18600/20000], Loss: 0.0617
  187. Epoch [18700/20000], Loss: 0.0616
  188. Epoch [18800/20000], Loss: 0.0615
  189. Epoch [18900/20000], Loss: 0.0614
  190. Epoch [19000/20000], Loss: 0.0613
  191. Epoch [19100/20000], Loss: 0.0612
  192. Epoch [19200/20000], Loss: 0.0610
  193. Epoch [19300/20000], Loss: 0.0609
  194. Epoch [19400/20000], Loss: 0.0608
  195. Epoch [19500/20000], Loss: 0.0607
  196. Epoch [19600/20000], Loss: 0.0606
  197. Epoch [19700/20000], Loss: 0.0605
  198. Epoch [19800/20000], Loss: 0.0605
  199. Epoch [19900/20000], Loss: 0.0604
  200. Epoch [20000/20000], Loss: 0.0603
复制代码
如果你重新运行上面这段练习循环，模型参数、优化器状态和梯度会继承保留，导致练习结果叠加，模型参数和优化器状态（如动量、学习率等）不会被重置。这会导致练习从之前的状态继承，而不是从头开始
3. 可视化结果

  1. import matplotlib.pyplot as plt
  2. # 可视化损失曲线
  3. plt.plot(range(num_epochs), losses)
  4. plt.xlabel('Epoch')
  5. plt.ylabel('Loss')
  6. plt.title('Training Loss over Epochs')
  7. plt.show()
复制代码

六、通俗解释

1. 环境安装（相称于买锅碗瓢盆）​​



  • ​​PyTorch​​：就像买了一套厨房工具，用来“炒菜”（练习模型）。
  • ​​CUDA​​：如果电脑有NVIDIA显卡（比如游戏本），可以加速“炒菜”速率，相称于用高压锅。
  • ​​查抄显卡​​：打开电脑的“工具箱”（命令行），输入nvidia-smi，看看有没有“高压锅”能用。
2. 数据准备（洗菜切菜）​​


  • ​​鸢尾花数据集​​：就像你有三种差别颜色的花（Setosa、Versicolor、Virginica），每朵花有四个特性（花瓣长度、宽度等）。
  • ​​数据分割​​：把花分成两堆，一堆用来“学做菜”（练习集），另一堆用来“考试”（测试集）。
  • ​​归一化​​：把花的特性数据“调音量”，比如把花瓣长度从0-3cm变成0-1的比例，制止某些特性太大影响模型。
3. 模型界说（设计菜谱）​​



  • ​​MLP模型​​：就是一个“做菜流程”，比如：

    • ​​第一层（洗菜+切菜）​​：输入4个特性（花瓣、萼片数据），经过10个“小帮忙”（神经元）处理。
    • ​​激活函数（ReLU）​​：像“过滤器”，只保留重要的信息（比如过滤掉不新鲜的花）。
    • ​​第二层（炒菜）​​：把处理后的信息交给3个“大厨”（神经元），输出三个概率（预测是哪种花）。

  1. # 代码比喻：定义菜谱
  2. class MLP(nn.Module):
  3.     def __init__(self):
  4.         super().__init__()
  5.         self.layer1 = nn.Linear(4, 10)  # 输入4个特征，输出10个中间结果
  6.         self.layer2 = nn.Linear(10, 3)  # 输入10个中间结果，输出3种花的概率
复制代码
​​4. 练习过程（炒菜实操）​​

（1）损失函数（老师的评分）​​


  • ​​交织熵损失​​：老师会根据你的预测打分，比如你猜是Setosa（概率0.8），但实际是Versicolor，老师会扣分。
（2）优化器（调解火候）​​


  • ​​SGD（手动翻炒）​​：每次根据老师评分调解火候（学习率），比如火候太大会烧焦（参数更新太大），太小炒不熟（收敛慢）。
  • ​​Adam（自动翻炒）​​：更智能的火候调解，适合新手。
（3）练习循环（重复炒菜）​​


  • ​​前向流传​​：把菜放进锅里炒（输入数据经过模型）。
  • ​​反向流传​​：根据老师评分，分析那边炒糊了（盘算梯度）。
  • ​​参数更新​​：调解盐、油量（模型参数），让下次炒菜更好吃。
  1. # 代码比喻：炒菜过程
  2. for epoch in range(20000):
  3.     outputs = model(X_train)  # 把菜放进锅里炒
  4.     loss = criterion(outputs, y_train)  # 老师打分
  5.     optimizer.zero_grad()  # 清空锅里的油（梯度清零）
  6.     loss.backward()  # 分析为什么难吃（反向传播）
  7.     optimizer.step()  # 调整火候（更新参数）
复制代码
​​5. 评估与可视化（考试和总结）​​


  • ​​测试集​​：用没炒过的菜（测试集）考验模型，看能对几道题（准确率）。
  • ​​损失曲线​​：画一张“扣分趋势图”，如果扣分越来越少，阐明越炒越好。
6. ​​通俗总结​​



  • ​​神经网络​​：就是一个“自动炒菜机器人”，通过不断试错（练习），学会根据食材特性（花瓣长度）判断菜品类型（花的种类）。
  • ​​关键点​​：

    • ​​数据要干净​​（归一化）：就像洗菜要洗干净。
    • ​​模型要设计合理​​：就像菜谱步骤不能乱。
    • ​​练习要有耐烦​​：炒菜要反复调解火候。

7. 类比问答​​



  • ​​Q：为什么需要激活函数？​​
    A：防止模型变成“只会背答案的笨学生”，比如不管输入什么，都输出同样的结果。激活函数让模型学会“思索”（引入非线性）。
  • ​​Q：为什么用GPU？​​
    A：GPU就像有100个厨师同时炒菜，速率飞快。CPU只有一个厨师，适合慢慢做风雅菜品（简单盘算）。
  • ​​Q：为什么标签要是Long类型？​​
    A：由于模型需要明确知道“精确答案是数字0、1、2”，而不是浮点数（比如0.0、1.0）。


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
继续阅读请点击广告

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

×
回复

使用道具 举报

返回列表

饭宝
+ 我要发帖
×
登录参与点评抽奖，加入IT实名职场社区
去登录
快速回复 返回顶部 返回列表