<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
    <channel>
        <title>基础概念 on Lumenth</title>
        <link>https://blog.lumenth.me/tags/%E5%9F%BA%E7%A1%80%E6%A6%82%E5%BF%B5/</link>
        <description>Recent content in 基础概念 on Lumenth</description>
        <generator>Hugo -- gohugo.io</generator>
        <language>zh-cn</language>
        <copyright>Lumenth</copyright>
        <lastBuildDate>Fri, 25 Sep 2026 16:21:31 +0800</lastBuildDate><atom:link href="https://blog.lumenth.me/tags/%E5%9F%BA%E7%A1%80%E6%A6%82%E5%BF%B5/index.xml" rel="self" type="application/rss+xml" /><item>
        <title>深度学习笔记-关键概念</title>
        <link>https://blog.lumenth.me/p/conception/</link>
        <pubDate>Fri, 18 Sep 2026 00:00:00 +0000</pubDate>
        
        <guid>https://blog.lumenth.me/p/conception/</guid>
        <description>&lt;img src="https://blog.lumenth.me/p/conception/wallpaper.png" alt="Featured image of post 深度学习笔记-关键概念" /&gt;&lt;h1 id=&#34;关键概念&#34;&gt;关键概念
&lt;/h1&gt;&lt;p&gt;这篇整理几个后面会反复出现的名词：前向传播、激活函数、损失函数、梯度下降、学习率。它们不是某个具体模型，而是所有神经网络训练时都要用到的共同零件。&lt;/p&gt;
&lt;p&gt;一个神经网络的训练过程，本质上就是这五样东西的配合：先&lt;strong&gt;前向传播&lt;/strong&gt;算出预测值，用&lt;strong&gt;损失函数&lt;/strong&gt;衡量它和正确答案差多少，再靠&lt;strong&gt;梯度下降&lt;/strong&gt;把参数往误差减小的方向挪一点，每次挪多大由&lt;strong&gt;学习率&lt;/strong&gt;决定；而&lt;strong&gt;激活函数&lt;/strong&gt;决定了每一层的输出长什么样，也决定了整个网络能不能表达非线性。&lt;/p&gt;
&lt;h2 id=&#34;前向传播&#34;&gt;前向传播
&lt;/h2&gt;&lt;p&gt;数据从输入层进入，沿着网络逐层往后算，直到输出层给出预测值，这个过程就叫前向传播（Forward Propagation）。(&lt;strong&gt;简单理解就是将上一层的输出作为下一层的输入，并计算下一层的输出，一直到运算到输出层为止。&lt;/strong&gt;)&lt;/p&gt;
&lt;p&gt;沿用&lt;a class=&#34;link&#34; href=&#34;../MLP/&#34; &gt;多层感知机笔记&lt;/a&gt;的记号，&lt;code&gt;i&lt;/code&gt; 表示层号：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;第 i 层的净输入：z&lt;sub&gt;(i)&lt;/sub&gt; = W&lt;sub&gt;(i)&lt;/sub&gt;a&lt;sub&gt;(i−1)&lt;/sub&gt; + b&lt;sub&gt;(i)&lt;/sub&gt;&lt;/li&gt;
&lt;li&gt;第 i 层的输出：a&lt;sub&gt;(i)&lt;/sub&gt; = σ(z&lt;sub&gt;(i)&lt;/sub&gt;)&lt;/li&gt;
&lt;li&gt;输入层 a&lt;sub&gt;(0)&lt;/sub&gt; = x，最后一层的输出就是预测值 ŷ&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;需要强调两点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;前向传播&lt;strong&gt;不更新任何参数&lt;/strong&gt;，它只是拿着当前这组参数做一次预测，看结果怎么样；&lt;/li&gt;
&lt;li&gt;但每一层的 z 和 a &lt;strong&gt;必须保存下来&lt;/strong&gt;，因为反向传播算梯度时要直接复用这些中间结果，重算一遍代价太大。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;激活函数&#34;&gt;激活函数
&lt;/h2&gt;&lt;p&gt;激活函数套在每一层&amp;quot;加权求和之后、往下传递之前&amp;quot;，负责把 z&lt;sub&gt;(i)&lt;/sub&gt; 变成该层的输出 a&lt;sub&gt;(i)&lt;/sub&gt;。&lt;/p&gt;
&lt;p&gt;它最重要的作用是引入非线性。如果去掉激活函数、每层只做线性变换，那么无论堆多少层，最终都等价于一层线性模型（推导见&lt;a class=&#34;link&#34; href=&#34;../MLP/&#34; &gt;多层感知机笔记&lt;/a&gt;），网络就失去了拟合复杂函数的能力。&lt;/p&gt;
&lt;p&gt;常见选择：&lt;/p&gt;
&lt;h3 id=&#34;&#34;&gt;
&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;阶跃函数&lt;/strong&gt;：最朴素的激活函数，&lt;a class=&#34;link&#34; href=&#34;../Perceptron/&#34; &gt;感知机&lt;/a&gt;用的就是它；但处处导数为 0、在 0 处不可导，梯度传不下去，因此只能用于单层模型。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img src=&#34;https://blog.lumenth.me/p/conception/STEP.png&#34;
	width=&#34;474&#34;
	height=&#34;306&#34;
	srcset=&#34;https://blog.lumenth.me/p/conception/STEP_hu_e571fbeca0cc2201.png 480w, https://blog.lumenth.me/p/conception/STEP_hu_9706fefe7fd06e24.png 1024w&#34;
	loading=&#34;lazy&#34;
	
	
		class=&#34;gallery-image&#34; 
		data-flex-grow=&#34;154&#34;
		data-flex-basis=&#34;371px&#34;
	
&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;ReLU&lt;/strong&gt;：正区间导数为 1、负区间为 0，计算极快且不饱和，是目前隐藏层的默认选择；缺点是可能出现&amp;quot;死亡 ReLU&amp;quot;（神经元永久输出 0）。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img src=&#34;https://blog.lumenth.me/p/conception/RELU.png&#34;
	width=&#34;585&#34;
	height=&#34;322&#34;
	srcset=&#34;https://blog.lumenth.me/p/conception/RELU_hu_a563401ea52b802c.png 480w, https://blog.lumenth.me/p/conception/RELU_hu_6cc69ccf0417586a.png 1024w&#34;
	loading=&#34;lazy&#34;
	
	
		class=&#34;gallery-image&#34; 
		data-flex-grow=&#34;181&#34;
		data-flex-basis=&#34;436px&#34;
	
&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Sigmoid&lt;/strong&gt;：把输出压到 (0,1)，适合二分类的输出层；缺点是两端饱和后梯度趋近 0，容易梯度消失，且输出非零均值。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img src=&#34;https://blog.lumenth.me/p/conception/SIGMOID.png&#34;
	width=&#34;607&#34;
	height=&#34;312&#34;
	srcset=&#34;https://blog.lumenth.me/p/conception/SIGMOID_hu_40b792ba9341ee17.png 480w, https://blog.lumenth.me/p/conception/SIGMOID_hu_8a0eb3343be0ea7f.png 1024w&#34;
	loading=&#34;lazy&#34;
	
	
		class=&#34;gallery-image&#34; 
		data-flex-grow=&#34;194&#34;
		data-flex-basis=&#34;466px&#34;
	
&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Tanh&lt;/strong&gt;：把输出压到 (−1,1)，零均值，隐藏层比 Sigmoid 好用一些；同样存在梯度消失。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img src=&#34;https://blog.lumenth.me/p/conception/TANH.png&#34;
	width=&#34;636&#34;
	height=&#34;322&#34;
	srcset=&#34;https://blog.lumenth.me/p/conception/TANH_hu_3b4a0b9a5dcbb64a.png 480w, https://blog.lumenth.me/p/conception/TANH_hu_3383d8862e7dca89.png 1024w&#34;
	loading=&#34;lazy&#34;
	
	
		class=&#34;gallery-image&#34; 
		data-flex-grow=&#34;197&#34;
		data-flex-basis=&#34;474px&#34;
	
&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Softmax&lt;/strong&gt;：不属于单个神经元的激活函数，而是作用在输出层的一整组神经元上，把它们的输出归一化成总和为 1 的概率，专用于多分类的输出层。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img src=&#34;https://blog.lumenth.me/p/conception/SOFTMAX.png&#34;
	width=&#34;161&#34;
	height=&#34;76&#34;
	srcset=&#34;https://blog.lumenth.me/p/conception/SOFTMAX_hu_8b0057dc6437b877.png 480w, https://blog.lumenth.me/p/conception/SOFTMAX_hu_da93cc849c0257d7.png 1024w&#34;
	loading=&#34;lazy&#34;
	
	
		class=&#34;gallery-image&#34; 
		data-flex-grow=&#34;211&#34;
		data-flex-basis=&#34;508px&#34;
	
&gt;&lt;/p&gt;
&lt;p&gt;一句话总结：隐藏层默认用 ReLU，二分类输出用 Sigmoid，多分类输出用 Softmax。&lt;/p&gt;
&lt;h2 id=&#34;损失函数&#34;&gt;损失函数
&lt;/h2&gt;&lt;p&gt;损失函数（Loss Function）用来衡量预测值 ŷ 和真实标签 y 之间的差距，输出一个标量 L 代表损失。&lt;/p&gt;
&lt;p&gt;它是训练的&lt;strong&gt;目标&lt;/strong&gt;：模型训练得好不好，就看损失能不能降下来。常见形式：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;回归任务：&lt;strong&gt;均方误差&lt;/strong&gt; &lt;code&gt;L = ½ ‖ŷ − y‖&amp;lt;sup&amp;gt;2&amp;lt;/sup&amp;gt;&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;二分类任务：&lt;strong&gt;交叉熵&lt;/strong&gt;，配合 Sigmoid 输出使用&lt;/li&gt;
&lt;li&gt;多分类任务：&lt;strong&gt;交叉熵&lt;/strong&gt;，配合 Softmax 输出使用&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;损失函数有两个要求：一是能真实反映&amp;quot;错得多离谱&amp;quot;，二是&lt;strong&gt;必须可导&lt;/strong&gt;——因为后面要根据它对每个参数求偏导，参数才知道该往哪调。这也是为什么要选用 Sigmoid、ReLU 而不是阶跃函数的原因之一。&lt;/p&gt;
&lt;p&gt;在整个训练流程里，损失函数正好卡在中间：前向传播算出 ŷ，损失函数把它变成一个可以求导的标量 L，反向传播再由这个 L 出发往回算梯度（反向传播）。&lt;/p&gt;
&lt;h2 id=&#34;梯度下降&#34;&gt;梯度下降
&lt;/h2&gt;&lt;p&gt;有了损失，接下来要让损失 L 变小。梯度（偏导数组成的向量）指向的是 L &lt;strong&gt;上升最快&lt;/strong&gt;的方向，那么每个参数的更新方向就很自然了——沿着梯度的反方向走：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;div class=&#34;chroma&#34;&gt;
&lt;table class=&#34;lntable&#34;&gt;&lt;tr&gt;&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code&gt;&lt;span class=&#34;lnt&#34;&gt;1
&lt;/span&gt;&lt;span class=&#34;lnt&#34;&gt;2
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class=&#34;lntd&#34;&gt;
&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-fallback&#34; data-lang=&#34;fallback&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;W ← W − η · ∂L/∂W
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;b ← b − η · ∂L/∂b
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;p&gt;这就是梯度下降（Gradient Descent），可以想象成站在山坡上蒙着眼往下山走：每次用脚探一下周围哪个方向最陡（求梯度），然后朝最陡的下坡方向迈一小步（更新参数），重复若干次就到了山谷附近。&lt;/p&gt;
&lt;p&gt;按每次用多少样本来算梯度，分成三种：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;批量梯度下降&lt;/strong&gt;：用全部训练样本算一次梯度再更新，方向稳但慢；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;随机梯度下降（SGD）&lt;/strong&gt;：每次只用一个样本，更新快但抖动大；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;小批量梯度下降&lt;/strong&gt;：每次用一小批样本（如 32、64 个），兼顾稳定与速度，实际最常用。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;需要注意的是，梯度下降拿到的是当前点的&lt;strong&gt;局部信息&lt;/strong&gt;，它不保证走到全局最低点：遇到局部极小值或鞍点都可能卡住或减速。&lt;/p&gt;
&lt;h2 id=&#34;学习率&#34;&gt;学习率
&lt;/h2&gt;&lt;p&gt;学习率（Learning Rate）η 就是上面公式里那个&amp;quot;步长&amp;quot;，控制每次参数更新的幅度。&lt;/p&gt;
&lt;p&gt;它是最重要也最容易调错的超参数：&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;https://blog.lumenth.me/p/conception/xuexilv.png&#34;
	width=&#34;1250&#34;
	height=&#34;449&#34;
	srcset=&#34;https://blog.lumenth.me/p/conception/xuexilv_hu_ba85e924b4d4e647.png 480w, https://blog.lumenth.me/p/conception/xuexilv_hu_f445074ba4fd8560.png 1024w&#34;
	loading=&#34;lazy&#34;
	
	
		class=&#34;gallery-image&#34; 
		data-flex-grow=&#34;278&#34;
		data-flex-basis=&#34;668px&#34;
	
&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;太大&lt;/strong&gt;：一步跨过头，损失在最低点附近来回震荡，甚至越更新越大直接发散；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;太小&lt;/strong&gt;：每步都几乎没有进展，收敛极慢，还容易停在半路上；&lt;/li&gt;
&lt;li&gt;比较稳妥的做法是&lt;strong&gt;让学习率随训练衰减&lt;/strong&gt;：前期大步靠近，后期小步微调。也可以交给 Adam 这类自适应优化器，让每个参数各自拥有动态调整的步长。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;小结&#34;&gt;小结
&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;前向传播&lt;/strong&gt;：拿着当前参数算出预测值，并把每层的中间结果存下来备用；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;激活函数&lt;/strong&gt;：给线性变换加非线性，否则多层网络等价于单层；隐藏层默认 ReLU，输出层按任务选 Sigmoid 或 Softmax；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;损失函数&lt;/strong&gt;：量化预测与真实的差距，必须可导，是前向与反向之间的分界点；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;梯度下降&lt;/strong&gt;：沿梯度反方向更新参数来减小损失，实践中多用小批量；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;学习率&lt;/strong&gt;：控制每一步走多大，太大发散、太慢卡住，通常随训练衰减。&lt;/li&gt;
&lt;/ul&gt;
</description>
        </item>
        
    </channel>
</rss>
