在构建神经网络模型的时候，除了网络结构设计以外，选取合适的优化算法也对网络起着至关重要的作用，本文将对神经网络中常用的优化算法进行简单的介绍和对比，本文部分参考了 Ruder 的关于梯度下降优化算法一文 ¹。首先，我们对下文中使用的符号进行同意说明：网络中的参数同一表示为 $\theta$，网络的假设函数为 $h_{\boldsymbol{\theta}}\left(\boldsymbol{x}\right)$，网络的损失函数为 $J\left(\boldsymbol{\theta}\right)$，学习率为 $\alpha$，假设训练数据中共包含 $m$ 个样本，网络参数个数为 $n$。

梯度下降

在梯度下降算法中，常用的主要包含 3 种不同的形式，分别是批量梯度下降 (Batch Gradient Descent, BGD)，随机梯度下降 (Stochastic Gradient Descent, SGD) 和小批量梯度下降 (Mini-Batch Gradient Descent, MBGD)。一般情况下，我们在谈论梯度下降时，更多的是指小批量梯度下降。

BGD

BGD 为梯度下降算法中最基础的一个算法，其损失函数定义如下：

$$ J \left(\boldsymbol{\theta}\right) = \dfrac{1}{2m} \sum_{i=1}^{m}{\left(h_{\boldsymbol{\theta}}\left(x^{\left(i\right)}\right) - y^{\left(i\right)}\right)} $$

针对任意参数 $\theta_j$ 我们可以求得其梯度为：

$$ \nabla_{\theta_j} = \dfrac{\partial J\left(\boldsymbol{\theta}\right)}{\partial \theta_j} = - \dfrac{1}{m} \sum_{i=1}^{m}{\left(y^{\left(i\right)} - h_{\boldsymbol{\theta}} \left(x^{\left(i\right)}\right)\right) x_j^{\left(i\right)}} $$

之后，对于任意参数 $\theta_j$ 我们按照其负梯度方向进行更新：

$$ \theta_j = \theta_j + \alpha \left[\dfrac{1}{m} \sum_{i=1}^{m}{\left(y^{\left(i\right)} - h_{\boldsymbol{\theta}} \left(x^{\left(i\right)}\right)\right) x_j^{\left(i\right)}}\right] $$

整个算法流程可以表示如下：

    
\begin{algorithm}
\caption{BGD 算法}
\begin{algorithmic}
\FOR{$epoch = 1, 2, ...$}
    \FOR{$j = 1, 2, ..., n$}
        \STATE $J \left(\boldsymbol{\theta}\right) = \dfrac{1}{2m} \sum_{i=1}^{m}{\left(h_{\boldsymbol{\theta}}\left(x^{\left(i\right)}\right) - y^{\left(i\right)}\right)}$
        \STATE $\theta_j = \theta_j - \alpha \dfrac{\partial J\left(\boldsymbol{\theta}\right)}{\partial \theta_j}$
    \ENDFOR
\ENDFOR
\end{algorithmic}
\end{algorithm}

  

从上述算法流程中我们可以看到，BGD 算法每次计算梯度都使用了整个训练集，也就是说对于给定的一个初始点，其每一步的更新都是沿着全局梯度最大的负方向。但这同样是其问题，当 $m$ 太大时，整个算法的计算开销就很高了。

SGD

SGD 相比于 BGD，其最主要的区别就在于计算梯度时不再利用整个数据集，而是针对单个样本计算梯度并更新权重，因此，其损失函数定义如下：

$$ J \left(\boldsymbol{\theta}\right) = \dfrac{1}{2} \left(h_{\boldsymbol{\theta}}\left(x^{\left(i\right)}\right) - y^{\left(i\right)}\right) $$

整个算法流程可以表示如下：

    
\begin{algorithm}
\caption{SGD 算法}
\begin{algorithmic}
\FOR{$epoch = 1, 2, ...$}
    \STATE Randomly shuffle dataset
    \FOR{$i = 1, 2, ..., m$}
        \FOR{$j = 1, 2, ..., n$}
            \STATE $J \left(\boldsymbol{\theta}\right) = \dfrac{1}{2} \left(h_{\boldsymbol{\theta}}\left(x^{\left(i\right)}\right) - y^{\left(i\right)}\right)$
            \STATE $\theta_j = \theta_j - \alpha \dfrac{\partial J\left(\boldsymbol{\theta}\right)}{\partial \theta_j}$
        \ENDFOR
    \ENDFOR
\ENDFOR
\end{algorithmic}
\end{algorithm}

  

SGD 相比于 BGD 具有训练速度快的优势，但同时由于权重改变的方向并不是全局梯度最大的负方向，甚至相反，因此不能够保证每次损失函数都会减小。

MBGD

针对 BGD 和 SGD 的问题，MBGD 则是一个折中的方案，在每次更新参数时，MBGD 会选取 $b$ 个样本计算的梯度，设第 $k$ 批中数据的下标的集合为 $B_k$，则其损失函数定义如下：

$$ \nabla_{\theta_j} = \dfrac{\partial J\left(\boldsymbol{\theta}\right)}{\partial \theta_j} = - \dfrac{1}{|B_k|} \sum_{i \in B_k}{\left(y^{\left(i\right)} - h_{\boldsymbol{\theta}} \left(x^{\left(i\right)}\right)\right) x_j^{\left(i\right)}} $$

整个算法流程可以表示如下：

    
\begin{algorithm}
\caption{MBGD 算法}
\begin{algorithmic}
\FOR{$epoch = 1, 2, ...$}
    \FOR{$k = 1, 2, ..., m / b$}
        \FOR{$j = 1, 2, ..., n$}
            \STATE $J \left(\boldsymbol{\theta}\right) = \dfrac{1}{|B_k|} \sum_{i \in B_k}{\left(y^{\left(i\right)} - h_{\boldsymbol{\theta}} \left(x^{\left(i\right)}\right)\right) x_j^{\left(i\right)}}$
            \STATE $\theta_j = \theta_j - \alpha \dfrac{\partial J\left(\boldsymbol{\theta}\right)}{\partial \theta_j}$
        \ENDFOR
    \ENDFOR
\ENDFOR
\end{algorithmic}
\end{algorithm}

  

Momentum

当梯度沿着一个方向要明显比其他方向陡峭，我们可以形象的称之为峡谷形梯度，这种情况多位于局部最优点附近。在这种情况下，SGD 通常会摇摆着通过峡谷的斜坡，这就导致了其到达局部最优值的速度过慢。因此，针对这种情况，Momentum ² 方法提供了一种解决方案。针对原始的 SGD 算法，参数每 $t$ 步的变化量可以表示为

$$ \boldsymbol{v}_t = - \alpha \nabla_{\boldsymbol{\theta}} J \left(\boldsymbol{\theta}_t\right) $$

Momentum 算法则在其变化量中添加了一个动量分量，即

$$ \begin{equation} \begin{split} \boldsymbol{v}_t &= - \alpha \nabla_{\boldsymbol{\theta}} J \left(\boldsymbol{\theta}_t\right) + \gamma \boldsymbol{v}_{t-1} \\ \boldsymbol{\theta}_t &= \boldsymbol{\theta}_{t-1} + \boldsymbol{v}_t \end{split} \end{equation} $$

对于添加的动量项，当第 $t$ 步和第 $t-1$ 步的梯度方向相同时，$\boldsymbol{\theta}$ 则以更快的速度更新；当第 $t$ 步和第 $t-1$ 步的梯度方向相反时，$\boldsymbol{\theta}$ 则以较慢的速度更新。利用 SGD 和 Momentum 两种方法，在峡谷行的二维梯度上更新参数的示意图如下所示

NAG

NAG (Nesterov Accelerated Gradient) ³ 是一种 Momentum 算法的变种，其核心思想会利用“下一步的梯度”确定“这一步的梯度”，当然这里“下一步的梯度”并非真正的下一步的梯度，而是指仅根据动量项更新后位置的梯度。Sutskever ⁴ 给出了一种更新参数的方法：

$$ \begin{equation} \begin{split} \boldsymbol{v}_t &= - \alpha \nabla_{\boldsymbol{\theta}} J \left(\boldsymbol{\theta}_t + \gamma \boldsymbol{v}_{t-1}\right) + \gamma \boldsymbol{v}_{t-1} \\ \boldsymbol{\theta}_t &= \boldsymbol{\theta}_{t-1} + \boldsymbol{v}_t \end{split} \end{equation} $$

针对 Momentum 和 NAG 两种不同的方法，其更新权重的差异如下图所示：

AdaGrad

AdaGrad ⁵ 是一种具有自适应学习率的的方法，其对于低频特征的参数选择更大的更新量，对于高频特征的参数选择更小的更新量。因此，AdaGrad算法更加适用于处理稀疏数据。Pennington 等则利用该方法训练 GloVe ⁶ 词向量，因为对于出现次数较少的词应当获得更大的参数更新。

因为每个参数的学习速率不再一样，则在 $t$ 时刻第 $i$ 个参数的变化为

$$ \theta_{t, i} = \theta_{t-1, i} - \alpha \nabla_{\theta} J \left(\theta_{t-1, i}\right) $$

根据 AdaGrad 方法的更新方式，我们对学习率做出如下变化

$$ \theta_{t, i} = \theta_{t-1, i} - \dfrac{\alpha}{\sqrt{G_{t, i}} + \epsilon} \nabla_{\theta} J \left(\theta_{t-1, i}\right) $$

其中，$G_t$ 表示截止到 $t$ 时刻梯度的平方和；$\epsilon$ 为平滑项，防止除数为零，一般设置为 $10^{-8}$。AdaGrad 最大的优势就在于其能够自动调节每个参数的学习率。

Adadelta

上文中 AdaGrad 算法存在一个缺点，即其用于调节学习率的分母中包含的是一个梯度的平方累加项，随着训练的不断进行，这个值将会越来越大，也就是说学习率将会越来越小，最终导致模型不会再学习到任何知识。Adadelta ⁷ 方法针对 AdaGrad 的这个问题，做出了进一步改进，其不再计算历史所以梯度的平方和，而是使用一个固定长度 $w$ 的滑动窗口内的梯度。

因为存储 $w$ 的梯度平方并不高效，Adadelta 采用了一种递归的方式进行计算，定义 $t$ 时刻梯度平方的均值为

$$ E \left[g^2\right]_t = \rho E \left[g^2\right]_{t-1} + \left(1 - \rho\right) g^2_{t} $$

其中，$g_t$ 表示 $t$ 时刻的梯度；$\rho$ 为一个衰减项，类似于 Momentum 中的衰减项。在更新参数过程中我们需要其平方根，即

$$ \text{RMS} \left[g\right]_t = \sqrt{E \left[g^2\right]_t + \epsilon} $$

则参数的更新量为

$$ \Delta \theta_t = - \dfrac{\alpha}{\text{RMS} \left[g\right]_t} g_t $$

除此之外，作者还考虑到上述更新中更新量和参数的假设单位不一致的情况，在上述更新公式中添加了一个关于参数的衰减项

$$ \text{RMS} \left[\Delta \theta\right]_t = \sqrt{E \left[\Delta \theta^2\right]_t + \epsilon} $$

其中

$$ E \left[\Delta \theta^2\right]_t = \rho E \left[\Delta \theta^2\right]_{t-1} + \left(1 - \rho\right) \Delta \theta_t^2 $$

在原始的论文中，作者直接用 $\text{RMS} \left[\Delta \theta^2\right]_t$ 替换了学习率，即

$$ \Delta \theta_t = - \dfrac{\text{RMS} \left[\Delta \theta\right]_{t-1}}{\text{RMS} \left[g\right]_t} g_t $$

而在 Keras 源码中，则保留了固定的学习率，即

$$ \Delta \theta_t = - \alpha \dfrac{\text{RMS} \left[\Delta \theta\right]_{t-1}}{\text{RMS} \left[g\right]_t} g_t $$

RMSprop

RMSprop ⁸ 是由 Hinton 提出的一种针对 AdaGrad 的改进算法。参数的更新量为

$$ \Delta \theta_t = - \dfrac{\alpha}{\text{RMS} \left[g\right]_t} g_t $$

Adam

Adam (Adaptive Moment Estimation) ⁹ 是另一种类型的自适应学习率方法，类似 Adadelta，Adam 对于每个参数都计算各自的学习率。Adam 方法中包含一个一阶梯度衰减项 $m_t$ 和一个二阶梯度衰减项 $v_t$

$$ \begin{equation} \begin{split} m_t &= \beta_1 m_{t-1} + \left(1 - \beta_1\right) g_t \\ v_t &= \beta_2 v_{t-1} + \left(1 - \beta_2\right) g_t^2 \end{split} \end{equation} $$

算法中，$m_t$ 和 $v_t$ 初始化为零向量，作者发现两者会更加偏向 $0$，尤其是在训练的初始阶段和衰减率很小的时候 (即 $\beta_1$ 和 $\beta_2$ 趋近于1的时候)。因此，对其偏差做如下校正

$$ \begin{equation} \begin{split} \hat{m}_t &= \dfrac{m_t}{1 - \beta_1^t} \\ \hat{v}_t &= \dfrac{v_t}{1 - \beta_2^t} \end{split} \end{equation} $$

最终得到 Adam 算法的参数更新量如下

$$ \Delta \theta = - \dfrac{\alpha}{\sqrt{\hat{v}_t} + \epsilon} \hat{m}_t $$

Adamax

在 Adam 中参数的更新方法利用了 $L_2$ 正则形式的历史梯度 ($v_{t-1}$) 和当前梯度 ($|g_t|^2$)，因此，更一般的，我们可以使用 $L_p$ 正则形式，即

$$ \begin{equation} \begin{split} v_t &= \beta_2^p v_{t-1} + \left(1 - \beta_2^p\right) |g_t|^p \\ &= \left(1 - \beta_2^p\right) \sum_{i=1}^{t} \beta_2^{p\left(t-i\right)} \cdot |g_t|^p \end{split} \end{equation} $$

这样的变换对于值较大的 $p$ 而言是很不稳定的，但对于极端的情况，当 $p$ 趋近于无穷的时候，则变为了一个简单并且稳定的算法。则在 $t$ 时刻对应的我们需要计算 $v_t^{1/p}$，令 $u_t = \lim_{p \to \infty} \left(v_t\right)^{1/p}$，则有

$$ \begin{equation} \begin{split} u_t &= \lim_{p \to \infty} \left(\left(1 - \beta_2^p\right) \sum_{i=1}^{t} \beta_2^{p\left(t-i\right)} \cdot |g_t|^p\right)^{1/p} \\ &= \lim_{p \to \infty} \left(1 - \beta_2^p\right)^{1/p} \left(\sum_{i=1}^{t} \beta_2^{p\left(t-i\right)} \cdot |g_t|^p\right)^{1/p} \\ &= \lim_{p \to \infty} \left(\sum_{i=1}^{t} \beta_2^{p\left(t-i\right)} \cdot |g_t|^p\right)^{1/p} \\ &= \max \left(\beta_2^{t-1} |g_1|, \beta_2^{t-2} |g_2|, ..., \beta_{t-1} |g_t|\right) \end{split} \end{equation} $$

写成递归的形式，则有

$$ u_t = \max \left(\beta_2 \cdot u_{t-1}, |g_t|\right) $$

则 Adamax 算法的参数更新量为

$$ \Delta \theta = - \dfrac{\alpha}{u_t} \hat{m}_t $$

Nadam

Adam 算法可以看做是对 RMSprop 和 Momentum 的结合：历史平方梯度的衰减项 $v_t$ (RMSprop) 和 历史梯度的衰减项 $m_t$ (Momentum)。Nadam (Nesterov-accelerated Adaptive Moment Estimation) ¹⁰ 则是将 Adam 同 NAG 进行了进一步结合。我们利用 Adam 中的符号重新回顾一下 NAG 算法

$$ \begin{equation} \begin{split} g_t &= \nabla_{\theta} J \left(\theta_t - \gamma m_{t-1}\right) \\ m_t &= \gamma m_{t-1} + \alpha g_t \\ \theta_t &= \theta_{t-1} - m_t \end{split} \end{equation} $$

NAG 算法的核心思想会利用“下一步的梯度”确定“这一步的梯度”，在 Nadam 算法中，作者在考虑“下一步的梯度”时对 NAG 进行了改动，修改为

$$ \begin{equation} \begin{split} g_t &= \nabla_{\theta} J \left(\theta_t\right) \\ m_t &= \gamma m_{t-1} + \alpha g_t \\ \theta_t &= \theta_{t-1} - \left(\gamma m_t + \alpha g_t\right) \end{split} \end{equation} $$

对于 Adam，根据

$$ \hat{m}_t = \dfrac{\beta_1 m_{t-1}}{1 - \beta_1^t} + \dfrac{\left(1 - \beta_1\right) g_t}{1 - \beta_1^t} $$

则有

$$ \begin{equation} \begin{split} \Delta \theta &= - \dfrac{\alpha}{\sqrt{\hat{v}_t} + \epsilon} \hat{m}_t \\ &= - \dfrac{\alpha}{\sqrt{\hat{v}_t} + \epsilon} \left(\dfrac{\beta_1 m_{t-1}}{1 - \beta_1^t} + \dfrac{\left(1 - \beta_1\right) g_t}{1 - \beta_1^t}\right) \end{split} \end{equation} $$

上式中，仅 $\dfrac{\beta_1 m_{t-1}}{1 - \beta_1^t}$ 和动量项相关，因此我们类似上文中对 NAG 的改动，通过简单的替换加入 Nesterov 动量项，最终得到 Nadam 方法的参数的更新量

$$ \Delta \theta = - \dfrac{\alpha}{\sqrt{\hat{v}_t} + \epsilon} \left(\dfrac{\beta_1 m_{t-1}}{1 - \beta_1^{t+1}} + \dfrac{\left(1 - \beta_1\right) g_t}{1 - \beta_1^t}\right) $$

AMSGrad

对于前面提到的 Adadelta，RMSprop，Adam 和 Nadam 方法，他们均采用了平方梯度的指数平滑平均值迭代产生新的梯度，但根据观察，在一些情况下这些算法并不能收敛到最优解。Reddi 等提出了一种新的 Adam 变体算法 AMSGrad ¹¹，在文中作者解释了为什么 RMSprop 和 Adam 算法无法收敛到一个最优解的问题。通过分析表明，为了保证得到一个收敛的最优解需要保留过去梯度的“长期记忆”，因此在 AMSGrad 算法中使用了历史平方梯度的最大值而非滑动平均进行更新参数，即

$$ \begin{equation} \begin{split} m_t &= \beta_1 m_{t-1} + \left(1 - \beta_1\right) g_t \\ v_t &= \beta_2 v_{t-1} + \left(1 - \beta_2\right) g_t^2 \\ \hat{v}_t &= \max \left(\hat{v}_{t-1}, v_t\right) \\ \Delta \theta &= - \dfrac{\alpha}{\sqrt{\hat{v}_t} + \epsilon} m_t \end{split} \end{equation} $$

作者在一些小数据集和 CIFAR-10 数据集上得到了相比于 Adam 更好的效果，但与此同时一些其他的 实验 却得到了相比与 Adam 类似或更差的结果，因此对于 AMSGrad 算法的效果还有待进一步确定。

算法可视化

正所谓一图胜千言，Alec Radford 提供了 2 张图形象了描述了不同优化算法之间的区别

左图为 Beale Function 在二维平面上的等高线，从图中可以看出 AdaGrad，Adadelta 和 RMSprop 算法很快的找到正确的方向并迅速的收敛到最优解；Momentum 和 NAG 则在初期出现了偏离，但偏离之后调整了方向并收敛到最优解；而 SGD 尽管方向正确，但收敛速度过慢。

右图为包含鞍点的一个三维图像，图像函数为 $z = x^2 - y^2$，从图中可以看出 AdaGrad，Adadelta 和 RMSprop 算法能够相对很快的逃离鞍点，而 Momentum，NAG 和 SGD 则相对比较困难逃离鞍点。

很不幸没能找到 Alec Radford 绘图的原始代码，不过 Louis Tiao 在 博客 中给出了绘制类似动图的方法。因此，本文参考该博客和 Keras 源码中对不同优化算法的实现重新绘制了 2 张类似图像，详细过程参见 源代码，动图如下所示：

环境信息

Matrix 是一种用于实时通讯的开放、去中心化协议，专注于安全、加密的文字、语音和视频聊天。它允许不同服务器上的用户互通，类似于邮件系统，并支持端到端加密，使用户能完全控制数据，不受单一实体限制。

Synapse 是一个使用 Python/Twisted 和 Rust 编写的开源 Matrix 服务器实现。本教程将介绍使用 Docker 容器部署 Matrix 服务器 Synapse。本教程涉及到的软件信息如下：

准备工作

数据库

为了支持中文搜索，在此选择内置 zhparser 分词功能的 PostgreSQL 镜像。在适当位置创建 PostgreSQL 的存储目录，例如 postgresql。运行如下命令生成配置：

docker run -d \
  --name postgresql \
  --restart always \
  -v $(pwd)/postgresql:/var/lib/postgresql \
  -e POSTGRES_USER=postgres \
  -e POSTGRES_PASSWORD=<密码> \
  -e ALLOW_IP_RANGE=0.0.0.0/0 \
  -p 5432:5432 \
  mixdeve/postgres-zhparser:18

相关参数说明如下：

进入数据库执行如下 SQL 进行配置：

-- 创建用户
CREATE USER synapse WITH PASSWORD '<密码>';

-- 创建数据库
CREATE DATABASE synapse WITH OWNER = synapse ENCODING = 'UTF8' LC_COLLATE = 'C' LC_CTYPE = 'C' TEMPLATE = template0;

-- 授权
GRANT ALL PRIVILEGES ON DATABASE synapse TO synapse;

缓存

为了提升服务性能，在此开启 Redis 缓存。在适当位置创建 Redis 的存储目录，例如 redis。运行如下命令启动 Redis 容器：

docker run -d \
  --name redis \
  --restart always \
  -v $(pwd)/redis:/data \
  -p 6379:6379 \
  redis:8 \
  redis-server --save 60 1 --appendonly yes

配置文件

进入服务器在适当位置创建 Synapse 的存储目录，例如 synapse。运行如下命令生成配置：

docker run -it --rm \
  -v $(pwd)/synapse:/data \
  -e SYNAPSE_SERVER_NAME=example.com \
  -e SYNAPSE_REPORT_STATS=no \
  -e SYNAPSE_HTTP_PORT=8008 \
  -e UID=1000 \
  -e GID=1000 \
  matrixdotorg/synapse:latest generate

相关参数说明如下：

修改配置文件服务部分如下：

public_baseurl: https://matrix-homeserver.example.com
serve_server_wellknown: true

修改配置文件数据库部分如下：

database:
  name: psycopg2
  txn_limit: 10000
  args:
    user: synapse
    password: <密码>
    dbname: synapse
    host: <数据库地址>
    port: 5432
    cp_min: 5
    cp_max: 10

修改配置文件缓存部分如下：

redis:
  enabled: true
  host: <数据库地址>
  port: 6379
  dbid: 0

启动服务

运行如下命令启动服务：

docker run -d \
  --name synapse \
  --restart always \
  -v $(pwd)/synapse:/data \
  -u 1000:1000 \
  -p 8008:8008 \
  matrixdotorg/synapse:latest

在服务商中配置 DNS 将 matrix-homeserver.example.com 解析至 Docker 服务器的 IP 地址。通过浏览器访问 http://matrix-homeserver.example.com:8008 即可查看 Synapse 服务是否启动成功。

中文搜索

在 PostgreSQL 数据中运行如下 SQL 安装 zhparser 扩展并配置中文搜索：

-- 创建 zhparser 扩展
CREATE EXTENSION IF NOT EXISTS zhparser;

-- 创建中文搜索配置
CREATE TEXT SEARCH CONFIGURATION chinese (PARSER = zhparser);
ALTER TEXT SEARCH CONFIGURATION chinese ADD MAPPING FOR n,v,a,i,e,l WITH simple;

-- 添加中文向量列
ALTER TABLE event_search ADD COLUMN IF NOT EXISTS chinese_vector tsvector;

-- 对已有数据进行中文分词处理
UPDATE event_search
SET chinese_vector =
  CASE
    WHEN event_search.key = 'content.body' AND TRIM(event_json.json::jsonb->'content'->>'body') != ''
      THEN to_tsvector('chinese', event_json.json::jsonb->'content'->>'body')
    WHEN event_search.key = 'content.name' AND TRIM(event_json.json::jsonb->'content'->>'name') != ''
      THEN to_tsvector('chinese', event_json.json::jsonb->'content'->>'name')
    WHEN event_search.key = 'content.topic' AND TRIM(event_json.json::jsonb->'content'->>'topic') != ''
      THEN to_tsvector('chinese', event_json.json::jsonb->'content'->>'topic')
    ELSE NULL
  END
FROM
  event_json
WHERE
  event_search.event_id = event_json.event_id
  AND (
    event_search.chinese_vector IS NULL
    OR event_search.chinese_vector::text = ''
  );

-- 创建中文索引
CREATE INDEX CONCURRENTLY event_search_chinese_vector_idx ON event_search USING GIN (chinese_vector);

将修改后的 search.py 文件映射至 Synapse 容器，删除之前的容器，运行如下命令重新创建容器：

docker run -d \
  --name synapse \
  --restart always \
  -v $(pwd)/synapse:/data \
  -v $(pwd)/synapse/search.py:/usr/local/lib/python3.13/site-packages/synapse/storage/databases/main/search.py \
  -u 1000:1000 \
  -p 8008:8008 \
  matrixdotorg/synapse:latest

发现服务

发现服务是 Matrix 网络发现服务器位置的一种方式。因为实际服务运行在子域名 matrix-homeserver.example.com 上，需要让其他服务器和客户端知道我们使用主域名，因此需要提供 /.well-known/matrix 信息。因此需要将 https://example.com/.well-known/matrix 映射到 https://matrix-homeserver.example.com/.well-known/matrix，相关细节请参考官方文档。

注册用户

Synapse 服务默认是禁止自助注册用户的，运行如下命令进入 Synapse 容器：

docker exec -it synapse /bin/bash

运行如下命令创建用户：

register_new_matrix_user http://localhost:8008 \
  -c /data/homeserver.yaml -a \
  -u "<用户名>" \
  -p "<密码>"

开始使用

在浏览器上打开 https://app.element.io，单击 Sign in 切换 Homeserver 到 example.com，输入用户名和密码即可登录。

环境信息

本教程将介绍在 macOS 和 Windows 环境下部署本地大模型服务。如无特殊说明，macOS 系统下需在终端中执行命令，Windows 系统下需要在 PowerShell 中执行命令。本教程涉及到的软件和模型信息如下：

为了加速从 Hugging Face 模型仓库下载模型，可以运行如下命令配置相关环境变量：

echo "HF_ENDPOINT=https://hf-mirror.com" >> ~/.bash_profile

[Environment]::SetEnvironmentVariable("HF_ENDPOINT", "https://hf-mirror.com", "User")

更多使用方式可参考 HF-Mirror 官方网站。

ollama

推荐在终端运行如下命令安装 ollama：

curl -fsSL https://ollama.com/install.sh | sh

irm https://ollama.com/install.ps1 | iex

运行如下命令可以显示当前安装的版本号：

ollama --version
# ollama version is 0.20.2

ollama 当前采用 ollama pull MODEL 命令下载模型，除了使用官方模型库中的模型名称外（例如：qwen3.5:27b-nvfp4），还可以使用 Hugging Face 的模型链接（例如：https://huggingface.co/lmstudio-community/Qwen3.5-27B-GGUF），运行如下命令下载模型：

ollama pull qwen3.5:27b-nvfp4
ollama pull https://huggingface.co/lmstudio-community/Qwen3.5-27B-GGUF

ollama 当前仅支持通过环境变量配置监听地址和端口，运行如下命令进行配置：

echo "OLLAMA_HOST=0.0.0.0:11434" >> ~/.bash_profile

[Environment]::SetEnvironmentVariable("OLLAMA_HOST", "0.0.0.0:11434", "User")

运行如下命令启动模型服务：

ollama run <模型名称>

ollama run <模型名称>

OLLAMA_LLM_LIBRARY="cpu_avx2" ollama serve <模型名称>

macOS

Windows

打开 ollama 主页面，选择对应的模型，即可开始对话：

macOS

Windows

模型服务运行在 http://127.0.0.1:11434，API 文档详见：https://docs.ollama.com/api/introduction。运行如下命令以 OpenAI 兼容的接口测试服务：

curl http://127.0.0.1:11434/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "<模型名称>",
        "messages": [
            {
                "role": "user",
                "content": "你好"
            }
        ]
    }'

iwr -Uri http://127.0.0.1:11434/v1/chat/completions `
    -Method Post `
    -ContentType "application/json" `
    -Body '{
        "model": "<模型名称>",
        "messages": [
            {
                "role": "user",
                "content": "你好"
            }
        ]
    }'

LM Studio

推荐从 LM Studio 官网下载安装包，并运行安装 LM Studio。如果只需要安装 LM Studio 核心，不需要 GUI 界面，则可以在终端运行如下命令：

curl -fsSL https://lmstudio.ai/install.sh | bash

irm https://lmstudio.ai/install.ps1 | iex

下载并安装所需的 Runtime，macOS 系统支持 GGUF 和 MLX 两种格式，Windows 系统仅支持 GGUF 格式。

macOS

Windows

打开 LM Studio 主页面，选择对应的模型，即可开始对话：

macOS

Windows

单击左侧的 按钮，单击 Local Server，将 Status 滑动至 Running 状态。模型服务运行在 http://127.0.0.1:1234，API 文档详见：https://lmstudio.ai/docs/developer。运行如下命令以 OpenAI 兼容的接口测试服务：

curl http://127.0.0.1:1234/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "<模型名称>",
        "messages": [
            {
                "role": "user",
                "content": "你好"
            }
        ]
    }'

iwr -Uri http://127.0.0.1:1234/v1/chat/completions `
    -Method Post `
    -ContentType "application/json" `
    -Body '{
        "model": "<模型名称>",
        "messages": [
            {
                "role": "user",
                "content": "你好"
            }
        ]
    }'

oMLX

推荐从 oMLX 官网下载安装包，并运行安装 oMLX。安装完毕后启动，并从 macOS 菜单栏或 Windows 系统托盘单击 oMLX 图标，选择 Start Server 启动服务。待服务启动后，单击 Admin Panel 从浏览器打开管理面板，初次登录需要设置 API Key。在 Models - Downloader 中可以直接从 Hugging Face 和 ModelScope 模型仓库下载模型。

在 Settings - Model Settings 中单击对应模型 STATUS 中的按钮载入模型。

单击 Chat 进入对话页面，选择对应的模型，即可开始对话：

模型服务运行在 http://127.0.0.1:8000。运行如下命令以 OpenAI 兼容的接口测试服务：

curl http://127.0.0.1:8000/v1/chat/completions \
    -H "Authorization: Bearer <API_KEY>" \
    -H "Content-Type: application/json" \
    -d '{
        "model": "<模型名称>",
        "messages": [
            {
                "role": "user",
                "content": "你好"
            }
        ]
    }'

vllm

在 macOS 系统上，使用 vllm-metal 库安装 vllm 服务，运行如下命令：

curl -fsSL https://raw.githubusercontent.com/vllm-project/vllm-metal/main/install.sh | bash

这会在 ~/.venv-vllm-metal 路径下创建一个 Python 虚拟环境，并安装 vllm 服务。运行如下命令即可删除安装：

rm -rf ~/.venv-vllm-metal

运行如下命令激活 Python 虚拟环境：

source ~/.venv-vllm-metal/bin/activate

运行如下命令启动 vllm 服务：

vllm serve <模型名称|模型路径>

模型服务运行在 http://127.0.0.1:8000，更多环境变量设置请参考：https://github.com/vllm-project/vllm-metal，更多命令行参数设置请参考：https://docs.vllm.ai/en/stable/api/。运行如下命令以 OpenAI 兼容的接口测试服务：

curl http://127.0.0.1:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "<模型名称>",
        "messages": [
            {
                "role": "user",
                "content": "你好"
            }
        ]
    }'

那只🦞

AI 的发展想必不用多说，速度之快远超我们的想象。将 AI 大事记和标普 500 ¹ 整合绘制折线图如下：

从图中可以看出，自 2015 年 OpenAI 成立以来，随着标普 500 指数的不断增高，AI 也在以倍速迅猛发展。毋庸置疑在这个时代，如果你不了解 AI，不紧跟 AI，那么你可能会很快就会被社会淘汰。随着一股“龙虾热”的到来，更是把 AI 的关注度推到了风口浪尖。积极的去拥抱新的技术，亲自下场去体验，这都是很好的事，但也大可不必因为 FOMO（Fear of Missing Out，错失恐惧症）而太过盲从。即使你全身心 100% 的投入，在 AI 的浪潮中依然会有你错失的，停下来根据自身的实际情况多一些思考，才是争取不被拍死在沙滩上的最好选择。Anyway，一人开发者的周末项目，在短短不到 5 个月的时间内登顶 GitHub，这里面所预示的变革也绝不是我这些许思考所能妄言定论的，让我们且行且悟吧。

前不久在组织内部（大部分成员并非技术背景）讨论 AI 应用的时候（彼时公司已经提供了内部免费版的龙虾供大家试用），我抛出了如下两个问题：

1. 有多少人尝试过私有化部署龙虾？
2. 如果由你自己承担龙虾的费用，你是否还会像当前这样使用龙虾？

第一个问题要从前不久如火如荼的排队装龙虾开始说起，从安装龙虾，再到卸载龙虾，每个时代都有每个时代的鸡蛋要领。晚点有篇文章 ² 不错，提到网上流传着的一个悖论：“如果你需要托人帮你安装龙虾，那么你可能就不太需要龙虾。”这句话多少有些偏激了，但意思就是那么个意思，如果连这部分技术都不了解，那么在使用龙虾的过程中一旦遇到一些复杂情况，你就会陷入“问虾你为什么不行”-“虾说因为 XXX”-“你说你自己不能解决码？”-“虾说 balabalabalabala”的死循环当中。或者换个角度，如果龙虾真的无论是从可用还是易用角度做到了极致，那么此时此刻是否还需要你这个人去用它呢？这时最重要的问题或许是我们这些碳基生物应该如何避免被硅基生物消灭吧？

第二个问题会比较实在些，天天在谈 ROI，公司出于更长远的战略考虑给到一定的免费额度，但如果需要实打实的花自己钱的时候你真的还会随便用吗？只能说当下很多人还没有被 AI 替代是因为 AI 的成本比我们这些牛马的工资还是要高的。我相信随着技术的不断发展，AI 的成本也会越来越低，此时我们更需要思考些更适合 AI 去做，哪些更适合我们去做，那些 AI 暂时还替代不了我们去做的才是我们的核心竞争力，再用 AI 把自己加持下才是最妙的。

生产力

AI 是一种先进的生产力，这个应该不太会有人否认吧。我个人总结其主要先进在两个方面：

1. 效率。AI 在效率提升上面的效果是有目共睹的，无论你的工作类型是什么样的，哪怕你是体力劳动者。只能说对脑力工作者的提效会更多些，尤其是那些流程化、重复性的工作，以运营类工作尤为明显。对我而言更好的代码补全也着实提高了我的开发效率。
2. 创新。对于一些复杂的不确定性工作，AI 可以给到我很多新奇的点子，启发我把复杂的任务成功解决。很难说这是真的“创新”，也许在 AI 的脑子中这并非新鲜事物，但之于我自己而言，确实给到我眼前一亮的惊喜。前不久 Anthropic 团队使用 16 个智能体从零开始构建了一个基于 Rust 的 C 语言编译器 ³。我很惊讶这么底层的能力就这样被自动实现了（我并没有去体验，单纯的惊讶），但也有人质疑这只是“临摹”而非“创作”。毕竟 AI 吃过的盐比我吃过的饭都要多得多得多。因此无须太纠结这是不是真的创新，之于你是，之于你在做的事儿是，那就是。

在谈及 AI 作为一种先进的生产力时，它与瓦特的蒸汽机、爱迪生的电灯泡、亦或是宾夕法尼亚大学的埃尼阿克并无差异，本质上都是社会生产环节中的一个辅助工具。

生产关系

根据定义来看，AI 确实“不是”生产关系，生产关系探讨的主要是“人”与“物”以及“人”与“人”的关系，例如：生产资料所有制，生产中的地位和相互关系，产品的分配方式等。但 AI 作为生产力却可以影响生产关系，我认为此时用“重塑”会更适合些，因为这波 AI 带来的冲击确实过于迅猛。

之前听过付鹏的几期演讲和相关的播客，他将套利 ⁴ 的核心归纳为价差、利差、汇差，而在这些之前，还会有信息差、认知差、执行差、竞争差、资源差等等。我个人不是很懂投资，买过的股票基金啥的大多也是赔的，听的这些投资内容更多是出于对经济和风险的进一步理解。AI 在帮助我们缩小信息差、认知差、执行差、竞争差、资源差这些方面比之前变得更有可能，尤其是对于我们这些屁民而言。试想一下，之前在一个未知领域遇到了一个问题，Google 一下，搜索引擎玩儿的溜的能多获取一些有用的信息，玩儿不转的就只能凭人品看看有没有靠谱的朋友帮你解惑一二了。如果你有钱那就另说了，此时你又营造了资源差，但 AI 在帮助大家提升认知上貌似是公平的，是容易的。那么当答案获取变得便宜之后，什么又变得昂贵了呢？勇气，执行力，还是？

前不久比较火的一个词应该是“一人公司”（OPC，One Person Company），一个由 AI 技术驱动产生的全新组织范式。如果把一人公司做到极致，貌似你只需要同你的 AI 进行直接交流，AI 可以帮你去对接客户，AI 可以帮你去做产品，AI 可以帮你去销售。此时“人”-“人”的关系就转变成了“人”-“AI”-“人”的关系，甚至是“人”-“AI”-“AI”-“人”的关系，谁知道你的 AI 对接的客户是不是也是一个 AI 呢？从内部视角来看也是一样，从养一只虾到养多只虾，从管多只虾到管一只管多只虾的虾。

  flowchart TD
    A[你] --> B(🦞#1)

  flowchart TD
    A[你] --> B(🦞#1)
    A[你] --> C(🦞#2)
    A[你] --> D(🦞#3)

  flowchart TD
    A[你] --> B(🦞#01)
    B --> C(🦞#11)
    B --> D(🦞#12)
    B --> E(🦞#13)

你时不时的 PUA 下你的虾，你的虾时不时的摸会儿鱼。作为基层管理者的监管虾忙着分配任务和验收结果，而作为大头兵的牛马虾快乐小狗般地研究是巧克力味儿的屎好还是屎味儿的巧克力好，最后把监管虾看得着急的不要不要的，还不敢和你真实汇报。等你下场去检查的时候，屎山已经高的望不到顶了。这不就是一个活脱脱的赛博职场吗？此时我只想说对你的虾好一点儿，交代任务时加个“请”字，可能比你说他笨更有用些，真的。

旧世界的神（各种差）力量正在减弱，新世界的神（AI）已然崛起 ⁵。生产力的跃升总是先行的，随后才是生产关系的重构，当生产力的“安装期”接近尾声时, 生产关系的变革将成为主线 ⁶，此时你的信仰又该何去何从？

技术平权

最后我想再谈一点儿技术平权，感觉“龙虾热”把技术平权又双叒叕一次拿到了台面上。有两个问题，我的观点分别如下：

1. 技术平权好吗？我认为技术平权整体来看是好的，如果技术平权存在的话。技术平权可以让更先进的技术平等的惠及每一个人，整体上会极大的提高生产力。但这也会引发一定的焦虑，当技术稀缺时，焦虑只发生在少数人之间，当它开始民主化后，焦虑会迅速扩散，这在组织推进 AI 落地时需要格外关注。
2. 技术平权存在吗？我认为技术平权不存在。上个世纪还在用打孔卡进行编程，高性能计算机的普及依旧没有让编程变成普惠技术。也许你会说技术进步的还不够，看看现在的 Vibe Coding，那我会说 Vibe Coding 真的不错，你真的用了吗？你用它写出来的东西应用在生产环境了吗？厉害的人在 Vibe Coding 中更上层楼，不行的人只是换了一种方式堆屎山。

在这里我并没有为我们这些所谓的“工程师”粉饰门面，也没有打消大家探索新世界积极性的意思。想表达的是在科技洪流中，我们更需要思辨，去伪存真，鸿沟永远存在，找到一条更好提升自己的路，平权不平权不重要，干得过别人才重要。周末读到一篇文章，在此分享出来：《谁在制造“龙虾热”？当我们穿过一场名为“技术平权”的幻梦》，观点因人而异，但希望可以缓解部分人的焦虑。

最后的最后

最后的最后，改编一下我比较喜欢的胡适先生的话「大胆假设，小心求证」，AI 时代的我们可以「积极拥抱（这是态度），审慎思考（这是行为）」。AI 作为生产力终究不能自发地改变现有的生产关系，仍需要人的主观能动性。如果未来有一天硅基生命崛起，彼时的人类又是否会变成如当下的 AI 一样，成为一种“工具”，只不过是一种作为被奴役的稀有的资源般存在的“工具”。我不想这天的到来，至少在我有生之年。

缘起

从军事领域中的通信，到末世题材影视中的通联，再到越野中的车队通话，都让我对「无线电」这项技术感到高级和炫酷。可能在更多人的眼中无线电或是《永不消逝的电波》中发报机，亦或是保安大哥手中的对讲机。当你深入去了解的时候会发现，这东西不会那么遥不可及，当然也没有想象中那么简单，差评君的一期视频可以带你更好的了解什么是无线电。

那么什么又是业余无线电？莫非我们只配玩儿些不专业的东西？这里所说的“业余”并非技术角度的专业和不专业，而是指业余业务。业余无线电可以简单的理解为提供给我们这些业余爱好者使用的无线电。业余无线电的英文为 Amateur Radio，业余无线电爱好者称为 Radio Amateur，世界上也普遍称之为 HAM，所以“火腿”也就成为了业余无线电爱好者的代名词。

考试

想要合法合规的进行业余无线电操作，首先需要通过业余无线电台操作技术能力验证，类似开车一样你需要先考一个驾照。业务无线电台操作技术能力验证有不同等级，A 类、B 类和 C 类的区别如下：

申请人初次申请业余无线电台操作技术能力考核，须首先参加 A 类业余无线电台操作技术能力考试。取得 A 类操作证书六个月后可以申请参加 B 类操作技术能力考试。取得 B 类操作证书并且设置 B 类业余无线电台二年后，可以申请参加 C 类操作技术能力考试。

不同于考驾照，业务无线电台操作技术能力验证仅有理论考试，各地的考试报名方式不尽相同，更多的考试细节和题库可以参考业余无线电模拟考试平台。通过考试后，就可以收到业务无线电台操作技术能力验证证书了。

设备

拿到操作证书后，你就可以选择一台心怡的设备了，买完设备后你还需要去验机。这里最重要的一点就是你购买的设备型号必须有国家颁发的核准代码，没有核准代码的设备是无法通过验机的。

针对新手小白的对讲机选购可以参考下面这个视频，只能说没有最好的，从价格、性能、颜值等角度选择适合自己的就好。

我最终选择的是「如意通 6900 DMR」双模对讲机。之所以选择它是早些时间有了解到有 MMDVM 盒子这么一个东西，也想着入坑玩一下，所以就选择了一款有数字模式的对讲机。验机完毕后，就会收到一张中华人民共和国无线电台执照。

相比操作证书，无线电台执照简陋了不少，就是一张纸，所以可以去淘宝买一个保护套装上。此时你就得到了正式的呼号，现在就可以打开对讲机，开始你的第一次联通了：

我的呼号是 BD1CZP。翻阅了下资料，我国的呼号由 4 部分构成：

1. 第一位的 B 代表中国。
2. 第二位表示电台种类，A、D、G、H、I 代表业余电台，J 代表业余信标台和卫星业余电台，R 代表业余中继台。
3. 第三位表示地区：
   • 1：北京、卫星业余业务
   • 2：黑龙江、辽宁、吉林
   • 3: 天津、河北、内蒙古、山西
   • 4: 上海、山东、江苏
   • 5: 浙江、江西、福建
   • 6: 安徽、河南、湖北
   • 7: 湖南、广东、广西、海南
   • 8: 四川、重庆、贵州、云南
   • 9: 陕西、甘肃、宁夏、青海
   • 0：新疆、西藏
4. 后续几位则为分配的后缀。

报完呼号后为啥又来了 BRAVO, DELTA, ONE, CHARLIE, ZULU, PAPA 这么一段？这是因为为了避免在信号传播过程受到干扰导致失真或衰减，使得对一些字母的听辨产生困难，在通信中会使用字母解释法复述呼号。

除了标准解释以外，有时候也会使用其他单词替代：

QSL

QSL 在通信用的 Q 简语中是“收妥了”“给收据”的意思。QSL 卡片是业余电台特有的一种确认联络或收听的凭证，每个电台都应该有自己的 QSL 卡片。QSL 卡片一般长为 14-15 厘米，宽为 9-10 厘米，除了必须印有醒目的本台呼号外，还应该包含如下内容：

1. 接收方的呼号。
2. 确认是通联还是收听。
3. 联络的日期和时间。
4. 联络时所用的频率。
5. 联络时所用的模式。
6. 对方的信号情况。
7. 设备情况：型号、功率、天线等。
8. 操作者签名。

设计了一个自己的 QSL 卡片，如有需要源文件可单击下载：正面 & 反面。

十一之前看了原子能 UP 主的一期视频，最开始只是有感于当前工作中的代码开发，后来又有感于工作和生活，想着记录下来，又担心酸腐味太重就没写。十一回来，玩儿了两天，出了趟差，愈发感觉还是应该记录下，待回头看时至少可供自嘲。

之于代码

视频中讲到了一个“鸿沟理论”，高科技产品在市场营销过程中遭遇的最大障碍就是早期市场和主流市场之间存在的鸿沟，能否顺利的跨越鸿沟进入主流市场成功赢得实用主义者的支持决定了一个产品的成败。还有个“巴斯扩散模型”和这个理论很类似，原来还基于它做过一些预测模型。

早期市场中的产品就是我们通常说的 MVP。MVP 最重要的是速度，需要快速在市场中得到验证。所以从风险和收益的角度出发，在 MVP 开发的时候大家会快速地实现产品功能，一些细节（例如代码质量）往往就没那么重要。这一点我很认同，但是这里有个前提是面向市场的产品，在我的工作中，会有不少“就是要做”的事情，一定程度上是“刚需”，做得好做的差都得用。那这个时候大家又会怎么选择呢？我观察到的情况是大部分人还是会选择快速上线，因为要“拿结果”，虽没有市场去评价你，但你的老板会去评价你。

视频中给到的结论是：任何时候都不适合重构。经过早期市场的验证，当多个玩家都在拼命渡河赢得主流市场时，如果你慢了就很容易被赢家通吃，所以此时此刻你仍需要同时间赛跑。当终于在主流市场站稳脚跟后是不是真的就可以重构了，答案是依旧不行，因为这个时候已经积累了足够的技术债，重构的成本已经远远高于 MVP 时期。此时在风险和收益之间的人们往往不会为了一个收益不明朗的价值回报去承担一个不小的成本。尤其是在当前的环境下，没有铁饭碗的人不会想着为别人做嫁衣，有铁饭碗的人不会没事儿给自己找麻烦。

我给到的观点是：任何时候都适合重构，而且我认为这并不偏激。重构不一定代表需要大刀阔斧，有些时候你的改动甚至可以其他人都无感，只要对你的后续开发和维护有益，你认同这一点，就有动力去做。如果你没打算在团队长待，或者你就想当个甩手掌柜，亦或是你并非正编，那权当我没说（这三种情况我认为存在且普遍）。当真的需要启动治理需要推翻重来时，我们就需要现实些，此时可能需要更量化的风险披露，更好的上价值，更好的汇报，拉更多的人下水，事情才更容易如你所愿。

重构是有意义的，好一句废话，但我还是会时不时的想一想，不想连去做的勇气都不再会有。做多少，何时做，如何做，这里面的“度”每个人的想法就千差万别了，别因为此太过影响自己的绩效，那就尝试做一些，如果你超会上价值，也全当我多虑了。还有一点我认为需要多践行工程师文化，多一些思考，多一些规范，多 Review 一下自己的代码，这些不会太影响和时间赛跑的。我不图未来接手我代码的人夸我写的漂亮，只求不会骂我的代码是屎山。

之于工作

在之前的博客中有聊到自己的第二次职业焦虑，一年过去了，焦虑缓解了，但新的问题或者说想法变多了。谈及自己我都会说我是一个风险厌恶的人，这点到现在也没有太变（所以说改变一个人的一些想法真的挺难的），但我对风险有了新的认知。一次出差飞机上三个小时听了关于塔勒布的一个播客，还没来得及更深入的去了解，但让我记住了一个词“勇气”。对于工作而言，重构往小了说可以是内部职责的一次调整，往大了说可以是寻求一个新的外部机会，我能找出促使我要去这么做的千万个理由，但确没有太多去这么做的“勇气”。

我会更在意失去的，好比上面说的，风险是确定的（失去的），但收益是不明朗的（确定不会是一个更深的坑）。相比一年前，我最大的改变在于动起来了，确实缓解焦虑最好的方式就是行动起来。我们需要更加深入地剖析要不要做出变动，但不应持续地陷入剖析而不自拔。动起来，担心失去就先“小”动起来，不用让人看见（让人看见可能对你也没好处），自我发起的改变也不应是一蹴而就的，多些准备会让你少些担忧。

这段时间刷到短视频上的一句话：听说过上班累死的，没听说过不上班饿死的。我希望可以更加阳光的理解这句话，拼搏奋斗仍应是我们要去追求的，只是说哪怕做错了什么，你又能失去多少呢，相信只要能远离黄赌毒，就不至于把自己玩儿死。

之于生活

最近一年的感觉自己有些腐朽味，四年前的我还能一个人去摩旅，今年的我连近郊都没怎么去，貌似生活也进入了急需重构的阶段。但还不如工作，都还谈不上有没有动力去改变，连想要的生活的样子似乎都有些模糊了。最近看到豆瓣上也可以听播客了，之前都是在苹果自带的 APP 上听（简洁又没广告），但豆瓣推给我的一个播单甚得我意，有点豆瓣书籍和影视年度榜单的味道。随即发了个朋友圈分享了下，一个朋友回复到“这岂不是会天天蹿到你出去玩”，我回复到“出去玩就不听了，出不去才只能听听人家的过过瘾”。这一刻，我有在想是没了出去的勇气，还是连出去的想法都没了？

昨晚在短视频上刷到一个在澳大利亚的华人，记录了一些和当地人的生活日常，去过一次澳大利亚，那种地广人稀的氛围自己还是比较喜欢的。无论是播客还是短视频，难道真的是娱乐至死，或许可以从减少些刷短视频开始，立马走出去不现实，但把这两年没怎么读的书补一补还是可以试一试的。

前几天和部门里面年轻的同事聊到大学的专业（怎么就聊到这想不起来了，上了年纪确实记性不好），还能记得管理学老师的一句话：读万卷书不如行万里路，行万里路不如交万名友，交万名友不如名师之路。名师指路可遇不可求，庆幸求学期和工作期间能遇到几位带我的好师傅，行万里路真的可以体验更多（人生百态皆在其中），不过经济性不如读书。真的有好久没有好好的读几本书了，之前可以挑灯夜读，很想搞清楚为什么现在不行了，想了想也没太想明白，也许没那么重要搞清楚，有这时间去读更好些。那天我还说他们这些年轻人正值好时候（回头想想这话有点儿爹味儿），自己已经有些老了，感觉在重构生活的路上，借口多了太多，虽然每个人的情况各不相同，所以到底在害怕失去什么呢？这个答案就留在我完成重构那天再补上吧，希望有这一天，希望这一天不要太晚。

为了对比提升分辨率后的图片质量，我们先下载一张原始的高清图片 ¹，通过 ImageMagick 命令将其转换为一个低分辨率低质量的图片，未来基于这张转换后的图片进行分辨率和质量的提升，再与原始图片进行对比验证提升的效果。

magick toucan-raw.jpg -resize 512x -quality 10 toucan-low-res.jpg

基础操作

单击左侧 按钮进入 Upscaling 界面，将上面生成的低分辨率图片拖入 Assets 中，之后再拖入到 Upscale 面板的图片区域。

安装的 SDXL 模型包中包含一个 SwinIR 分辨率提升模型。选择该模型并添加如下的正向和负向提示词：

a vibrant bird, detailed, a high contrast, inviting warmth, sunlit elements, dynamic composition, 35mm lens, 1/2.8, environmental context, detailed har photography

blurry, out of focus, over saturated, text+++

将 Creativity 和 Structure 保持默认值 0，单击 Invoke 按钮生成图片。生成完毕后在 Assets 中的低分辨图片上右键，单击 按钮选择进行对比，单击 Images 选项卡回到新生成的图片页面查看对比效果。

从如下的对比中可以看出，生成的图片具有更多的细节，这样我们就可以在更高的分辨率下获得更加清晰锐利的图像。

单击画布上方的 Exit Compare 退出对比，在生成的图片上右键，单击 按钮可以在新窗口中打开图片，之后则可以使用鼠标进行放大来观察图片细节。

进阶操作

除了基础的分辨率提升以外，还有一些高级选项可以用来控制分辨率提升后的图片与原始图片的相似程度以及在提升分辨率过程中的创意性。Creativity 参数用于设置提示词控制图像生成的创意性，从而控制与原始图像的差异程度，值越大表示越具有创意性。Structure 参数用于确保分辨率提升过程中图像中的元素与原始图像中的元素的形状和位置匹配，值越大表示越会严格遵守原始图片的结构。

同时也可以调整生成的模型及其相关参数，例如：Scheduler 和 CFG Scale 等。

风格调整

如果在提升分辨率的过程中还希望调整图片的风格，你可以尝试使用不同的提示词，例如下面是一个绘画风格的提示词：

a painting of a vibrant bird, oil painting, deep impasto, glazed brushstrokes

我们适当增加 Creativity 的值到 8，减少 Structure 的值到 -4，这样可以给到模型更多的自由度重新构思一些细节。最后我们来综合对比原始图片、低分辨率图片、提升分辨率后的图片以及调整风格的图片：

至此，我们 Invoke AI 101 系列的 6 节课程就全部结束了，希望大家能够通过这 6 节课程对 Invoke AI 的功能有一个基础的认知。也期待大家能够进一步探索 Invoke AI 的高级功能，去创造更多自己喜欢的图片。

首先，我们使用 Juggernaut XL v9 模型和如下提示词生成一张基础图片留作备用：

提示词模板：

Environment Art

正向提示词：

futuristic terraced structure built into a mountain at dusk, twilight hues, lush greenery illuminated by soft glowing lights, multiple levels, pathways, vast mountain range, distant winding roads, glowing city lights below, towering otherworldly rock formations

为了保证可复现性，在生成这张图片时可以将随机数种子 Seed 固定，此处设置为 42。

边界框

将生成的图片拖入画布并创建一个新的 Raster Layer。在画布上单击 Bbox 按钮，此时图片的周围将显示一个边界框，使用鼠标按住可以拖动边界框的位置，放在边界框的四角可以调整边界框的大小。

将边界框移动到画布的一个完全空白的区域，此时边界框中没有任何 Raster Layer 的内容，单击 Invoke 会生成一张新的图片。

将边界框移动到画布的一个包含部分 Raster Layer 内容的区域，单击 Invoke 会将空白的部分补全，通常称之为 Out Painting 或 Infilling。

如果边界框和 Raster Layer 完全重合，单击 Invoke 将会基于当前 Raster Layer 中的内容重新生成新的图片，通常称之为图像到图像（Image2Image）。

修复蒙版

修复蒙版（Inpaint Mask）用于控制在边界框中哪些区域会被修改。在图层中单击 + 新建一个 Inpaint Mask 图层。单击画布上的 按钮后，则可以在画布上绘制所需要修改的区域。

此时可以将边界框进行缩放并移动到关注的指定区域。从左侧的 Image 面板中可以看到边界框的大小为 320x320。

但在图片生成过程中，仍然会以 1024x1024 分辨率进行生成，再通过缩放填充到边界框中。由于先生成了分辨率更高的图片，再进行的缩放，此时生成的部分可以具有更多的细节。这使得我们可以在不牺牲图片质量的前提下，对于图片的复杂区域进行优化。

修复蒙版可以让我们很方便的在图片中添加、移除和改变元素。例如，我们希望在楼梯台阶上添加两个人，可以按照如下步骤进行操作：

1. 将边界框调整到一个合适的大小和位置。
2. 创建一个 Inpaint Mask 图层，使用画笔勾勒出需要修改的区域。
3. 返回 Raster Layer，选择一个颜色，使用画笔勾勒出两个人的大概位置。
4. 在提示词的前面添加 two people。
5. 选择一个合适的 Denoising Strength，此处设置为 0.7，单击 Invoke 按钮启动生成。

可以看出，在修复蒙版区域内，根据 Raster Layer 的修改和提示词的修改成功的在台阶上添加了两个人。

在图片生成过程中你需要认识到提示词并非在任何时候都是有效的。相同的提示词在一个模型上可以获得很好的生成效果，但在另一个模型上可能无法生成所需的图片。这是由于模型训练所使用的图片和图片的标注文本不同所导致的，因此模型的提示词指南会格外重要。这也是为什么训练自己的模型会更好，因为你完全清楚在训练模型时所使用的标注文本。

在本节教程中我们不会讨论如何训练模型，我们将重点介绍不同模型之间的差异，展示它们如何影响图片生成的过程。除此之外我们还会讨论概念适配器（通常也称为 LoRA），来帮助你更好的理解相关工具。

模型比较

进入模型管理页面，在添加模型选项卡处选择 HuggingFace，输入 cagliostrolab/animagine-xl-4.0 下载 Animagine XL 4.0 模型。Animagine XL 模型与其他的通用模型有很大的不同，Animagine XL 模型是一个动漫主题的 SDXL 微调模型。Animagine XL 4.0 基于 Stable Diffusion XL 1.0 进行重新训练所得，它使用了 840 万张不同来源不同动漫风格的图片进行微调。

Animagine XL 模型使用了一套自有的数据标注方法进行训练，提示词指南如下图所示：

整个提示词包含 6 个部分：

1. 性别。例如：1girl/1boy/1other。
2. 角色。例如：remilia scarlet。
3. 来源作品。例如：touhou。
4. 分级。例如：safe, sensitive, nsfw, explicit。
5. 一般标签。
6. 质量标签。例如：masterpiece, high score, great score, absurdres。

建议的负向提示词如下：

lowres, bad anatomy, bad hands, text, error, missing finger, extra digits, fewer digits, cropped, worst quality, low quality, low score, bad score, average score, signature, watermark, username, blurry

Animagine XL 模型支持一些特殊的标签用于控制图片生成。质量标签直接影响生成图像的整体质量和细节水平。可用的质量标签有：masterpiece，best quality，low quality，worst quality。

与质量标签相比，分数标签可以对图像质量进行更细致的控制。在 Animagine XL 模型中，它们对输出质量的影响更大。可用的分数标签有：high score，great score，good score，average score，bad score，low score。

时间标签允许根据特定时间段或年份来控制生成图片的艺术风格。这对于生成具有特定时代艺术特征的图像非常有用。支持的年份标签有：year 2005，year {n}，year 2025。

利用如下正向和负向提示词分别使用 Animagine XL 4.0 模型和 Juggernaut XL v9 模型生成图片。

1boy, black hoodie, white spiky punk hair, nose piercing, standing against a brick wall, masterpiece, best quality, high score, great score

lowres, bad anatomy, bad hands, text, error, missing finger, extra digits, fewer digits, cropped, worst quality, low quality, low score, bad score, average score, signature, watermark, username, blurry

同时，为了比较提示词在不同模型中对生成图片的影响，再利用如下正向和负向提示词分别使用 Animagine XL 4.0 模型和 Juggernaut XL v9 模型生成图片。

1boy, black hoodie, white spiky punk hair, nose piercing, standing against a brick wall

lowres, bad anatomy, bad hands, text, error, missing finger, extra digits, fewer digits, cropped, signature, watermark, username, blurry

为了确保可复现，手动将随机数种子固定设置为 42，生成的图片如下：

不难看出，从正向和负向提示词中删除关于图片质量的关键词后，Animagine XL 4.0 模型生成的图片有显著的画质降低，而 Juggernaut XL v9 模型生成的图片质量变化并不大。实验说明提示词在不同的模型中效果存在差异，你必须了解模型的训练过程才能更好的使用提示词生成所需的图片。

概念适配器

上述问题就导致了概念适配器的诞生，通过自己训练概念适配器，你可以完全掌握对于模型的修改。进入模型管理页面，在添加模型选项卡处选择 HuggingFace，输入 nerijs/pixel-art-xl 下载 Pixel Art XL 概念适配器。利用如下正向和负向提示词分别使用 Animagine XL 4.0 模型和 Juggernaut XL v9 模型生成图片。

1boy, black hoodie, white spiky punk hair, nose piercing, standing against a brick wall, masterpiece, best quality, high score, great score, pixel art style

lowres, bad anatomy, bad hands, text, error, missing finger, extra digits, fewer digits, cropped, worst quality, low quality, low score, bad score, average score, signature, watermark, username, blurry

在 Generation 中添加概念适配器 pixel-art-xl 并启用：

Pixel Art XL 概念适配器用于生成像素风格的图片，生成的图片如下：

需要注意，LoRA 这类概念适配器与用于训练的原始模型之间存在关联。概念适配器可以理解为一个模型的上层封装，其扩展和增强了某些概念。将其放在另一个模型上，其仍可以将这个概念应用到新的模型上，但质量可能会有所下降。这是因为训练概念适配器的底层模型与当前应用的模型可能有着不同的架构和假设。也就是说 LoRA 这类模型并不是一个完全独立的模型，而是一个专门为某个基础模型构建的适配器，但如果两个模型本质上非常相似，则 LoRA 具有一定的可移植性。

在之前的图像生成示例中，单击 Invoke 按钮后，整个图像生成过程会从一张静态噪声图像开始，模型会将噪声逐步转化为最终图片，整个过程如下图所示：

将噪声图像转化成最终图片的过程称之为降噪（Denoising）。

将示例图片拖拽至画布上，选择 New Raster Layer，示例图片如下 ¹：

在图层中，可以找到 Denosing Strength 参数：

Denosing Strength 用于控制初始图片或 Raster Layer 在降噪过程中影响最终输出图片的程度。设置较高的值会使降噪过程从一个具有更多噪声数据的图片开始，此时模型会具有更高的自由度根据提示词生成新的内容。

图像到图像和文本到图像的最主要区别在于图像生成的起点。文本到图像时从纯噪声开始，并根据提示词逐步细化。图像到图像则会根据 Denosing Strength 跳过前面的一些步骤，使用提供的图像作为起点。

以 a porcelain teacup on a table 作为提示词，选择 Photography (General) 作为提示词模板，分别将 Denosing Strength 设置为 0.2 和 0.8，生成的图片和原始图片对比如下：

可以看出，较高 Denosing Strength 值可以让模型具有更高的自由度生成图片，而设置较低的 Denosing Strength 值时生成的图片仅有少量的变化。除此之外，在控制层和参考图片上也可以设置 Denosing Strength 来取得不同的效果。

控制网络

控制层通常用作控制网络（ControlNet）在图片生成中以线或结构的形式来提供参考。在 SDXL 中，常用的预训练控制网络有 ¹：

Contour Detection (scribble)

Scribble 模型可以根据输入的图片生成线条画，处理后的图片作为原始图片的简化版本可以精准的捕捉图片的轮廓。

Depth Map

Depth Map 可以生成图片的深度图，在图片生成中模拟深度效果，从而创建更加逼真的 3D 图片。

Hard Edge Detection (canny)

Canny 边缘检测的原理是通过寻找强度突变来识别图片中的边缘。它能够准确的检测边缘并减少噪声和伪边缘，通过降低阈值可以识别更多的信息。采用 Canny 模型时，将会生成与检测到的边缘匹配的图片。

Pose Detection (openpose)

Openpose 模型可以检测身体、手部、面部等多个部位的关键点，在生成图片时可以控制人体的姿态。

Soft Edge Detection (softedge)

Softedge 模型与 Scribble 模型类似，处理后的图片作为原始图片的简化版本仅保留形状的柔和边缘和一些浅阴影。

Tile

Tile 模型的主要功能可以归结为如下两点：

1. 可以重新解读图片中的特定细节，并创建全新的元素。
2. 当全局指令与图片的局部或特定部分存在差异时，可以忽略这些指令。在这种情况下，它可以使用局部上下文指示图片生成。

Tile 模型可以作为增强图片质量和细节的工具。如果在图片中存在一些不足的地方，例如调整图片大小导致的模糊，Tile 模型可以有效的消除此类问题从而获得更加清晰锐利的图片。此外 Tile 模型还可以添加更多细节，从而提升图片的整体质量。

控制层

在图层中单击 + Control Layer 添加控制层，或者在图片库中将图片拖拽至画布上，选择 New Control Layer。

示例图片及其生成的提示词如下：

正向提示词：

futuristic terraced structure built into a mountain at dusk, twilight hues, lush greenery illuminated by soft glowing lights, multiple levels, pathways, vast mountain range, distant winding roads, glowing city lights below, towering otherworldly rock formations, dreamy sky with soft clouds

负向提示词：

painting, digital art, sketch, blurry

本教程以 Hard Edge Detection (canny) 模型为例，单击 Filter 中的 Advanced 可以进行更多的调整：

调整完毕各项参数后，单击 Apply 即可生成控制图片。

控制图片提供的线条可以为图片生成提供参考。在画布中，可以使用 、 和 等工具对控制图片进行添加或删除等微调操作。接下来对控制层进行设置：

1. Weight：用于设置控制图层在图片生成过程中的权重，值越大则图片生成时越会严格遵守控制线条。
2. Begin/End %：用于设置在图片生成过程中在何时使用控制图层，将其设置为 0% 至 100% 表示从图片生成开始至结束一直使用控制图层。调整开始和结束的百分比可以给到模型更多的灵活性，从而获得更好的生成图片。
3. Control Mode：包含多种控制模式用于调节控制层的相关性（CFG scale）：
   • Balanced：提示词和控制层同等重要。
   • Prompt：提示词更加重要。
   • Control：控制层更加重要。

不同的 Control Mode 的生成示例如下 ²：

单击 Invoke 开始生成图片。此时可以看到模型在控制线条的指示下开始生成图片。

由于将结束百分比设置为了 70%，生成的图片也具有一定的灵活创意。单击 会将生成的图片添加到 Raster Layer。单击 可以将画布保存到图片库中。新生成的图片和用于生成控制层的图片对比如下：

参考图片

接下来我们将添加一个参考图片，也称为 IP Adapter。模型会根据参考图片的风格和结构来生成图片。首先将参考图片添加到图片库，本教程中使用的图片如下 ³：

将图片拖拽至左侧 Reference Image 上。

在左侧将会创建一个 Reference Image，并可以对其进行相关设置。

1. 模型：在安装 SDXL 相关模型的情况下，选择 Standard Reference (IP Adapter ViT-H) 模型，这里可以选择 ViT-H、ViT-G 和 ViT-L 多种变种。
2. Mode：Style and Composition 表示参考样式和结构，Style 表示仅参考样式，Composition 表示仅参考结构。
3. Weight：类比控制层。
4. Begin/End %：类比控制层。

在本教程中，将参考图片的 Weight 设置为 0.7，将结束百分比设置为 70%，从而给到模型更多的自由度。删除之前生成的 Raster Layer，单击 Invoke 开始生成图片。应用参考图片生成的图片和之前生成的图片对比如下：

可以看出新生成的图片在遵循控制层的前提下同时应用了参考图片的白色风格。

局部指示

在新生成的图片中，可以看到左侧背景中的山峰也被应用了参考图片中的建筑风格。为了实现更精确的控制，可以选择局部参考图片，将图片拖拽至画布上，选择 New Regional Reference Image。

在画布上选择 ，设置合适的笔刷宽度，在画布上勾勒出需要应用参考的区域，这里我们仅勾勒出建筑所在的区域。

单击 Invoke 开始生成图片。应用局部参考图片生成的图片和应用参考图片生成的图片对比如下：

可以看出新生成的图片仅在勾勒的区域内与参考图片的白色风格保持了一致，背后的山峰仍根据提示词生成相应的风格。

基于文本的指示

除了基于图片的指示以外，还可以创建基于文本的局部指示。在图层中单击 +，选择 Reginal Guidance 创建局部指示。在画布上选择 ，设置合适的笔刷宽度，在画布上勾勒出需要应用参考的区域，这里我们勾勒出建筑后面的一座山峰。在 Reginal Guidance 中选择 + Prompt 并添加 lush greenery 提示词。

单击 Invoke 开始生成图片。应用局部基于文本的指示的图片和应用局部参考图片生成的图片对比如下：

可以看出新生成的图片在勾勒的山峰区域增加了郁郁葱葱的树木。

输入输出文件描述符

在 Linux 启动后，init 进程会创建 3 个特殊的文件描述符分配给输入输出。

默认情况下，程序经由标准输入（stdin）从键盘读取数据，并将标准输出（stdout）和标准错误（stderr）显示在屏幕上。

在 Linux 中，init 是所有进程的父进程，所有子进程均会继承父进程的文件描述符。因此在 Linux 中执行的所有程序都可以从 stdin 获取输入，并将结果打印到 stdout 中，同时将错误信息打印到 stderr 中。

重定向

当我们不希望从键盘获取标准输入或将标准输出和标准错误显示在屏幕上时，则需要采用重定向。

输出重定向

输出重定向的使用方式如下：

cmd [1-n]> [文件/文件描述符/设备等]

假设当前目录下存在一个名为 yes.txt 的文件，且不存在名为 no.txt 的文件。执行如下命令：

ls yes.txt no.txt

由于 yes.txt 存在，这部分结果将输出到 stdout，同时由于 no.txt 不存在，这部分结果将输出到 stderr。命令的输出结果为：

ls: cannot access 'no.txt': No such file or directory
yes.txt

执行如下命令：

ls yes.txt no.txt 1> success.log 2> fail.log

此时屏幕上将不再显示任何信息，当前目录下会生成 success.log 和 fail.log 两个文件。其中 1> success.log 表示将 stdout 重定向至 success.log，2> fail.log 表示将 stderr 重定向至 fail.log。因此 success.log 中的内容为 yes.txt，fail.log 中的内容为 ls: cannot access 'no.txt': No such file or directory。

重定向过程中，stdout 的文件描述符 1 可以省略，但 stderr 的文件描述符 2 不可以省略。因此，当只重定向 stdout 时，可简写为：

ls yes.txt no.txt > success.log

此时屏幕上依旧会显示 stderr 的内容 ls: cannot access 'no.txt': No such file or directory，而 stdout 的内容则被重定向至 success.log 文件中。

在 Linux 中 &- 和 /dev/null 是两个特殊的输出设备，均表示为空，输出到该设备相当于抛弃输出。因此如下两行命令分别会抛弃 stdout 和 stderr 的内容：

ls yes.txt no.txt 1>&-
ls yes.txt no.txt 2> /dev/null

& 可以表示当前进程中已经存在的描述符，&1 表示 stdout，&2 表示 stderr。因此我们可以将 stdout 和 stderr 重定向到相同文件：

ls yes.txt no.txt > out.log 2> out.log
ls yes.txt no.txt > out.log 2>&1

在上述两种方式中，第一种会导致 out.log 文件被打开两次，stdout 和 stderr 内容会相互覆盖。第二种由于 stderr 重定向给了 stdout，stdout 重定向给了 out.log，因此 out.log 仅被打开了一次。

使用 > 进行输出重定向时会先判断文件是否存在，如果存在会先删除再创建，不存在则直接创建，无论命令是否执行成功均会创建。使用 >> 进行重定向时，如果文件存在则会以添加方式打开，不存在则直接创建。

输入重定向

输入重定向的使用方式如下：

cmd [1-n]< [文件/文件描述符/设备等]

例如：

cat > out.txt < in.txt

此时命令将从 in.txt 文件中获取输入而非 stdin，并将结果重定向到 out.txt 文件中。

Here Document

Here Document 是一种特殊的重定向方式，可以用来将多行输入传递给命令，使用方式如下：

cmd << delimiter
    ...
delimiter

这会将中间的内容 ... 传递给命令。需要注意结尾处的 delimiter 的前后均不能包含任何字符，起始处的 delimiter 的前后空白字符将被忽略。最为常用的 delimiter 为 EOF，但这不是必须的，例如：

wc -l << SOMETHING
第一行
第二行
第三行
SOMETHING

上述命令的输出结果为：

3

管道

管道 | 可以将一个命令的 stdout 作为下一个命令的 stdin 使用，但无法对 stderr 进行处理。因此管道也可以理解为重定向的一种特殊形式。

假设存在一个如下内容的 test.txt 文档：

Here is a test in line 1.
Here is another test in line 2.
Here is something else in line 3.

利用如下命令可以过滤出包含 test 字符的行并显示行号：

cat test.txt | grep -n "test"

上述命令的输出结果为：

1:Here is a test in line 1.
2:Here is another test in line 2.

如果希望同时将 stdout 和 stderr 重定向到下一个命令的 stdin，可以采用如下方式：

ls yes.txt no.txt 2>&1 | grep "No such file or directory"

上述命令的输出结果为：

ls: no.txt: No such file or directory

上述命令也可以简写为：

ls yes.txt no.txt |& grep "No such file or directory"

CSS 中的布局 display 和定位 position 可以说是两个最基本的属性，其控制着元素在网页中的显示方式。之前对布局和定位可谓是一知半解，最终奏不奏效全凭一顿乱试 😂，想了想还是应该细致地了解下，后面虽不妄想写起代码来事半功倍，但至少不会再暴力遍历破解了。

盒模型

在介绍布局和定位之前，首先回顾一下 CSS 的盒模型。CSS 盒模型从外到内由外边距 margin、边框 border、内边距 padding 和内容 content 共 4 部分组成，如下图所示：

元素的宽度 width 为内容的宽度 + 左边框 + 有边框 + 左内边距 + 右内边距，上例中为 $360+10+10+10+10=400$；元素的的高度 height 为内容的高度 + 上边框 + 下边框 + 上内边距 + 下内边距，上例中为 $240+10+10+20+20=300$。在实际中，我们并不能直接设定内容的宽度和高度，只能设置元素的宽度和高度，而显示区域的宽度和高度则通过计算自动设定。

在 CSS 中广泛使用的有两种盒子模型：块级盒子（block box） 和 内联盒子（inline box）¹。

块级盒子有如下表现行为：

• 盒子会在内联方向上扩展并占据父容器在该方向上的所有可用空间，在绝大数情况下意味着盒子会和父容器一样宽。
• 每个盒子都会换行。
• width 和 height 属性可以发挥作用。
• 内边距、外边距和边框会将其他元素从当前盒子周围“推开”。

除非特殊指定，诸如标题 (<h1> 等) 和段落 (<p>) 默认情况下都是块级的盒子。

内联盒子有如下表现行为：

• 盒子不会产生换行。
• width 和 height 属性将不起作用。
• 垂直方向的内边距、外边距以及边框会被应用但是不会把其他处于 inline 状态的盒子推开。
• 水平方向的内边距、外边距以及边框会被应用且会把其他处于 inline 状态的盒子推开。

<a> 、<span>、<em> 以及 <strong> 都是默认处于 inline 状态的。

布局

在 CSS 中使用 display 属性控制元素的布局方式，上文中的 block 和 inline 是最常用的两种布局方式。除此之外还有一种介于块级盒子和内联盒子之间的布局方式，即 inline-block，其具有如下表现行为：

• 盒子不会产生换行。
• width 和 height 属性可以发挥作用。
• 内边距、外边距和边框会将其他元素从当前盒子周围“推开”。

上图分别展示了 display: inline 和 display: inline-block 两种布局 span 元素的显示差异。

弹性布局

弹性布局（Flexbox Layout，Flexible Box Layout） 旨在提供一种更加有效的方式来布局、对齐和分配容器中元素之间的空间，即使元素的大小是未知或动态的，这也就是称为“弹性”的原因。

弹性布局是一套完整的模块而非一个单一的属性，其中一些属性要设置在父元素（flex container） 上，一些属性要设置在子元素（flex items） 上。常规布局是基于块级元素和内联元素的的流向，而弹性布局是基于弹性流向（flex-flow directions）。下图展示了弹性布局的基本思想：

父元素属性

display

该属性启用弹性容器，为其子元素开启弹性上下文。

.container {
  display: flex; /* 或 inline-flex */
}

flex-direction

该属性定义了弹性流向，即基本思想中的 main-axis。

.container {
  flex-direction: row | row-reverse | column | column-reverse;
}

• row（默认）：ltr 时从左至右，rtl 时从右至左
• row-reverse：ltr 时从右至左，rtl 时从左至右
• column：从上至下
• column-reverse：从下至上

flex-wrap

默认情况下会将子元素放置在一行中，该属性用于设置换行模式。

.container {
  flex-wrap: nowrap | wrap | wrap-reverse;
}

• nowarp（默认）：所有子元素放置在一行中。
• wrap：允许换行，从上至下。
• wrap-reverse：允许换行，从下至上。

flex-flow

该属性是 flex-direction 和 flex-wrap 两个属性的简写。

.container {
  flex-flow: column wrap;
}

justify-content

该属性用于设置主轴（main axis）方向的对齐方式。

.container {
  justify-content: flex-start | flex-end | center | space-between | space-around | space-evenly | start | end | left | right ... + safe | unsafe;
}

• flex-start（默认）：将子元素排列在 flex-direction 起始位置。
• flex-end：将子元素排列在 flex-direction 结束位置。
• center：将子元素沿着 flex-direction 方向居中排列。
• space-between：将子元素沿着 flex-direction 方向均匀排列，第一个子元素位于起始位置，最后一个子元素位于结束位置。
• space-around：将子元素沿着 flex-direction 方向均匀排列，每个子元素周围分配相同的空间。
• space-evenly：将子元素沿着 flex-direction 方向均匀排列，每个子元素之间的间隔相同。

align-items

该属性用于设置交叉轴（cross axis）方向的对齐方式。

.container {
  align-items: stretch | flex-start | flex-end | center | baseline | first baseline | last baseline | start | end | self-start | self-end + ... safe | unsafe;
}

• stretch（默认）：拉伸并填充容器（仍遵守 min-width 和 max-width）。
• flex-start / start / self-start：子元素被放置在交叉轴的起始位置。
• flex-end / end / self-end：子元素被放置在交叉轴的结束位置。
• center：子元素在交叉轴上居中对齐。
• baseline：子元素沿着他们的基线对齐。

align-content

该属性用于设置当交叉轴上有额外的空间时容器多行的内部对齐方式，类似 justify-content 设置主轴上子元素的对齐方式。

.container {
  align-content: flex-start | flex-end | center | space-between | space-around | space-evenly | stretch | start | end | baseline | first baseline | last baseline + ... safe | unsafe;
}

• normal（默认）：子元素被放置到容器的默认位置。
• flex-start / start：子元素被放置到容器的起始位置。
• flex-end / end：子元素被放置到容器的结束位置。
• center：子元素被放置到容器的居中位置。
• space-between：子元素均匀分布，第一行在容器的起始位置，最后一行在容器的结束位置。
• space-around：子元素均匀分布，每行元素周围分配相同的空间。
• space-evenly：子元素均匀分布，每行元素之间的间隔相同。
• stretch：子元素拉伸占用剩余空间。

gap, row-gap, column-gap

该属性用于控制子元素之间的间距，其仅用于非边缘子元素之间的间距。

.container {
  display: flex;
  ...
  gap: 10px;
  gap: 10px 20px; /* row-gap column gap */
  row-gap: 10px;
  column-gap: 20px;
}

该属性产生的行为可以认为是子元素之间的最小间距。

子元素属性

order

默认情况下，子元素按照代码顺序排列。该属性可以控制子元素在容器中的顺序。

.item {
  order: 5; /* 默认为 0 */
}

flex-grow

该属性定义了子元素在必要时的扩张能力，其接受一个整数比例值用于设定子元素占用容器的空间。如果所有子元素的 flew-grow 都设置为 1，则所有子元素将评分容器的剩余空间；如果一个子元素的 flex-grow 设置为 2，则该子元素将尝试占用其他子元素 2 倍大小的空间。

.item {
  flex-grow: 4; /* 默认为 0 */
}

flex-shrink

该属性定义了子元素在必要时的收缩能力。

.item {
  flex-shrink: 3; /* 默认为 1 */
}

flex-basis

该属性定义了分配剩余空间之前子元素的默认大小。其可以为例如 20%、5rem 之类的长度或一个关键字。

.item {
  flex-basis:  | auto; /* 默认为 auto */
}

flex

该属性是 flex-grow、flex-shrink 和 flex-basis 三个属性的简写。

.item {
  flex: none | [ <'flex-grow'> <'flex-shrink'>? || <'flex-basis'> ]
}

align-self

该属性可以覆盖由 align-items 指定的对齐方式。

.item {
  align-self: auto | flex-start | flex-end | center | baseline | stretch;
}

网格布局

网格布局（Grid Layout）是一种基于网格的布局系统，相比于沿轴线 一维布局 的弹性布局，网格布局可以看做是一种 二维布局。

核心概念

网格容器

网格容器即属性 display 为 grid 的元素，其为所有网格项目的直接父级。如下示例中，container 即为网格容器：

<div class="container">
  <div class="item item-1"> </div>
  <div class="item item-2"> </div>
  <div class="item item-3"> </div>
</div>

网格项目

网格项目为网格容器的直接后代。如下示例中，item 即为网格项目，但 sub-item 不是：

<div class="container">
  <div class="item"> </div>
  <div class="item">
    <p class="sub-item"> </p>
  </div>
  <div class="item"> </div>
</div>

网格线

网格线即构成网格结构的分界线。其可以是位于行或列任意一侧的垂直或水平线。如下示例中，黄色的线为一条列网格线：

网格单元

网格单元即两个相邻行和两个相邻列之间的区域。如下示例中，黄色区域为行网格线 1 和 2 以及列网格线 2 和 3 之间的单元格：

网格轨道

网格轨道即 2 条相邻网格线之间的区域，可以将其视为网格的行或列。如下示例中，黄色区域为第 2 行和第 3 行网格线之间的网格轨道：

网格区域

网格区域即 4 条网格线包围的区域，一个网格区域可以由任意数量的网格单元组成。如下示例中，黄色区域为行网格线 1 和 3 以及列网格线 1 和 3 之间的网格区域：

父元素属性

display

该属性启用网格容器，为其子元素开启网格上下文。

.container {
  display: grid | inline-grid;
}

grid-template-columns, grid-template-rows

该属性通过空格分隔的值列表定义网格的列和行，值代表轨道的大小。值列表包括：

• <track-size>：轨道大小，可以为长度、百分比等。
• <line-name>：网格线名称，可以为任意值。

.container {
  grid-template-columns: ...  ...;
  /* 例如：
      1fr 1fr
      minmax(10px, 1fr) 3fr
      repeat(5, 1fr)
      50px auto 100px 1fr
  */
  grid-template-rows: ... ...;
  /* 例如：
      min-content 1fr min-content
      100px 1fr max-content
  */
}

网格线默认将会被分为正整数（-1 作为最后一个的替代值）。

同时也可以明确指定这些线的名称，请注意括号命名语法：

.container {
  grid-template-columns: [first] 40px [line2] 50px [line3] auto [col4-start] 50px [five] 40px [end];
  grid-template-rows: [row1-start] 25% [row1-end] 100px [third-line] auto [last-line];
}

请注意，一个行或列可以有多个名称：

.container {
  grid-template-rows: [row1-start] 25% [row1-end row2-start] 25% [row2-end];
}

使用 repeat() 可以简化重复项：

.container {
  grid-template-columns: repeat(3, 20px [col-start]);
}

上述代码等效于：

.container {
  grid-template-columns: 20px [col-start] 20px [col-start] 20px [col-start];
}

如果多行或多列共享相同的名称，可以通过行名或列名和计数来引用它们：

.item {
  grid-column-start: col-start 2;
}

fr 单位允许将轨道的大小设置为网格容器可用空间的一定比例。例如，如下示例将每个项目设置为容器宽度的三分之一：

.container {
  grid-template-columns: 1fr 1fr 1fr;
}

可用空间是在所有非弹性项目之后计算得到。在上述示例中，fr 单位的可用空间总量不包括 50px：

.container {
  grid-template-columns: 1fr 50px 1fr 1fr;
}

grid-template-areas

该属性通过引用网格区域的名称 grid-area 来定义网格。重复网格区域名称会导致内容跨越这些单元格。句点表示一个空单元格。语法本身提供了网格结构的可视化。

• <grid-area-name>：网格区域的名称。
• .：空网格单元。
• none：未定义的网格区域。

.container {
  grid-template-areas:
    "<grid-area-name> | . | none | ..."
    "...";
}

.item-a {
  grid-area: header;
}
.item-b {
  grid-area: main;
}
.item-c {
  grid-area: sidebar;
}
.item-d {
  grid-area: footer;
}

.container {
  display: grid;
  grid-template-columns: 50px 50px 50px 50px;
  grid-template-rows: auto;
  grid-template-areas:
    "header header header header"
    "main main . sidebar"
    "footer footer footer footer";
}

上述示例将创建一个 4 列 3 行的网格。整个顶部为 header 区域，中间一行由 main 和 sidebar 两个区域和一个空单元格组成，最后一行为 footer。

声明中的每一行都需要有相同数量的单元格。可以使用任意数量的句点声明一个空单元格，只要句点之间没有空格，就代表一个单元格。

注意使用此语法仅可以命名区域，不可命名线。使用此语法时，区域两端的线会自动命名，如果网格区域名称为 foo，那么该区域的起始行线和起始列线名称为 foo-start，该区域的终止行线和终止列线名称为 foo-end。这意味着某些线可能有多个名称，上述示例中最左边的行线将有 3 个名称：header-start、main-start 和 footer-start。

grid-template

该属性是 grid-template-rows、grid-template-columns 和 grid-template-areas 三个属性的简写。

.container {
  grid-template: none | <grid-template-rows> / <grid-template-columns>;
}

其接受更复杂但更方便的语法来指定这三个值，例如：

.container {
  grid-template:
    [row1-start] "header header header" 25px [row1-end]
    [row2-start] "footer footer footer" 25px [row2-end]
    / auto 50px auto;
}

上述代码等效于：

.container {
  grid-template-rows: [row1-start] 25px [row1-end row2-start] 25px [row2-end];
  grid-template-columns: auto 50px auto;
  grid-template-areas:
    "header header header"
    "footer footer footer";
}

由于 grid-template 并不会重置网格的隐含属性（grid-auto-columns、grid-auto-rows 和 grid-auto-flow）。因此，建议使用 grid 属性而非 grid-template。

column-gap, row-gap, grid-column-gap, grid-row-gap

该属性用于指定网格线的大小，你可以将其看做列和行之间的间距。

.container {
  /* standard */
  column-gap: <line-size>;
  row-gap: <line-size>;

  /* old */
  grid-column-gap: <line-size>;
  grid-row-gap: <line-size>;
}

.container {
  grid-template-columns: 100px 50px 100px;
  grid-template-rows: 80px auto 80px;
  column-gap: 10px;
  row-gap: 15px;
}

间距仅在列和行之间创建，不在边缘创建。注意，带有 grid- 前缀的属性将被废弃。

gap, grid-gap

该属性为 row-gap 和 column-gap 两个属性的简写。

.container {
  /* standard */
  gap: <grid-row-gap> <grid-column-gap>;

  /* old */
  grid-gap: <grid-row-gap> <grid-column-gap>;
}

.container {
  grid-template-columns: 100px 50px 100px;
  grid-template-rows: 80px auto 80px;
  gap: 15px 10px;
}

如果未指定 row-gap，则它将被设置为与 column-gap 相同的值。注意，带有 grid- 前缀的属性将被废弃。

justify-items

沿 inline（行）轴对齐网格项（与沿 block（列）轴对齐 align-items 相反）。该属性将应用于容器内所有网格项。

• stretch（默认值）：将网格项填充至整个单元格宽度。
• start：将网格项与单元的起始边缘对齐。
• end：将网格项与单元的结束边缘对齐。
• center：将网格项与单元的中心对齐。

.container {
  justify-items: stretch | start | end | center;
}

.container {
  justify-items: stretch;
}

.container {
  justify-items: start;
}

.container {
  justify-items: end;
}

.container {
  justify-items: center;
}

align-items

沿 block（列）轴对齐网格项（与沿 inline（行）轴对齐 align-items 相反）。该属性将应用于容器内所有网格项。

• stretch（默认值）：将网格项填充至整个单元格高度。
• start：将网格项与单元的起始边缘对齐。
• end：将网格项与单元的结束边缘对齐。
• center：将网格项与单元的中心对齐。
• baseline：将网格项沿文本基线对齐。

.container {
  align-items: stretch | start | end | center;
}

.container {
  align-items: stretch;
}

.container {
  align-items: start;
}

.container {
  align-items: end;
}

.container {
  align-items: center;
}

通过 align-self 属性可以在单个网格项上覆盖由 align-items 指定的对齐方式。

place-items

该属性在单次声明中同时设置 align-items 和 justify-items 属性。

• <align-items> / <justify-items>：省略第二个值则将第一个值分配给两个属性。

.center {
  display: grid;
  place-items: center;
}

justify-content

当所有网格项均使用非弹性的单位（例如 px）来确定大小，则网格的总大小可能小于网格容器的大小。在这种情况下，可以在网格容器内设置网格的对齐方式。该属性沿 inline（行）轴（与沿 block（列）轴对齐 align-content 相反）对齐网格。

• start：将网格与网格容器的起始边缘对齐。
• end：将网格与网格容器的结束边缘对齐。
• center：将网格与网格容器的中心对齐。
• stretch ：调整网格项的大小使网格填充网格容器的整个宽度。
• space-around：每个网格项均匀分布，每个网格项周围分配相同的空间。
• space-between：每个网格项均匀分布，第一个网格项在起始位置，最后一个网格项在结束位置。
• space-evenly：每个网格项均匀分布，每个网格项之间的间隔相同。

.container {
  justify-content: start | end | center | stretch | space-around | space-between | space-evenly;
}

.container {
  justify-content: start;
}

.container {
  justify-content: end;
}

.container {
  justify-content: center;
}

.container {
  justify-content: stretch;
}

.container {
  justify-content: space-around;
}

.container {
  justify-content: space-between;
}

.container {
  justify-content: space-evenly;
}

align-content

当所有网格项均使用非弹性的单位（例如 px）来确定大小，则网格的总大小可能小于网格容器的大小。在这种情况下，可以在网格容器内设置网格的对齐方式。该属性沿 block（列）轴（与沿 inline（行）轴对齐 justify-content 相反）对齐网格。

• start：将网格与网格容器的起始边缘对齐。
• end：将网格与网格容器的结束边缘对齐。
• center：将网格与网格容器的中心对齐。
• stretch ：调整网格项的大小使网格填充网格容器的整个高度。
• space-around：每个网格项均匀分布，每个网格项周围分配相同的空间。
• space-between：每个网格项均匀分布，第一个网格项在起始位置，最后一个网格项在结束位置。
• space-evenly：每个网格项均匀分布，每个网格项之间的间隔相同。

.container {
  align-content: start | end | center | stretch | space-around | space-between | space-evenly;
}

.container {
  align-content: start;
}

.container {
  align-content: end;
}

.container {
  align-content: center;
}

.container {
  align-content: stretch;
}

.container {
  align-content: space-around;
}

.container {
  align-content: space-between;
}

.container {
  align-content: space-evenly;
}

place-content

该属性在单次声明中同时设置 align-content 和 justify-content 属性。

• <align-content> / <justify-content>：省略第二个值则将第一个值分配给两个属性。

grid-auto-columns, grid-auto-rows

该属性指定自动生成的网格轨道（也称为隐式网格轨道）的大小。当网格项多于网格中的单元格或当网格项放置在显示网格之外时，将创建隐式网格轨道。

• <track-size>：可以为长度、百分比或可用空间的比例（使用 fr 单位）。

.container {
  grid-auto-columns: <track-size> ...;
  grid-auto-rows: <track-size> ...;
}

.container {
  grid-template-columns: 60px 60px;
  grid-template-rows: 90px 90px;
}

上述代码将生成一个 2x2 的网格：

使用 grid-column 和 grid-row 来定位网格项：

.item-a {
  grid-column: 1 / 2;
  grid-row: 2 / 3;
}
.item-b {
  grid-column: 5 / 6;
  grid-row: 2 / 3;
}

.item-b 从第 5 列线开始到第 6 列线结束，但由于并未定义第 5 列线和第 6 列线，因此创建了宽度为 0 的隐式轨道用于填充间隙。使用 grid-auto-columns 和 grid-auto-rows 可以指定这些隐式轨道的宽度：

.container {
  grid-auto-columns: 60px;
}

grid-auto-flow

如果有未明确放置在网格中的网格项目，自动放置算法会自动放置这些网格项目。此属性用于控制自动放置算法的工作方式。

• row（默认）：依次填充每一行，并根据需要添加新行。
• column：依次填充每一列，并根据需要添加新列。
• dense：将可能较晚出现的较小的网格项优先填充在网格中。

.container {
  grid-auto-flow: row | column | row dense | column dense;
}

注意 dense 仅会改变网格项目的视觉顺序，这可能导致顺序混乱且不利于访问。

考虑如下示例：

<section class="container">
  <div class="item-a">item-a</div>
  <div class="item-b">item-b</div>
  <div class="item-c">item-c</div>
  <div class="item-d">item-d</div>
  <div class="item-e">item-e</div>
</section>

定义一个包含 5 列和 2 行的网格，并将 grid-auto-flow 设置为 row：

.container {
  display: grid;
  grid-template-columns: 60px 60px 60px 60px 60px;
  grid-template-rows: 30px 30px;
  grid-auto-flow: row;
}

将网格项目放置在网格中时，只需要为其中两个指定位置：

.item-a {
  grid-column: 1;
  grid-row: 1 / 3;
}
.item-e {
  grid-column: 5;
  grid-row: 1 / 3;
}

因为将 grid-auto-flow 设置为了 row，未放置的三个网格项目（item-b、item-c 和 item-d）如下所示：

.container {
  display: grid;
  grid-template-columns: 60px 60px 60px 60px 60px;
  grid-template-rows: 30px 30px;
  grid-auto-flow: column;
}

如果将 grid-auto-flow 设置为 column，未放置的三个网格项目（item-b、item-c 和 item-d）如下所示：

grid

该属性为 grid-template-rows、grid-template-columns、grid-template-areas、grid-auto-rows、grid-auto-columns 和 grid-auto-flow 属性的简写。

• none：将所有子属性设置为初始值。
• <grid-template>：同 grid-template。
• <grid-template-rows> / [ auto-flow && dense? ] <grid-auto-columns>?：设置 grid-template-rows 为指定值。如果使用 auto-flow 关键字，则设置 grid-auto-flow 为 colomn。如果额外使用 dense 关键字，则自动放置算法将使用 dense 算法。如果省略 grid-auto-columns，则其被设置为 auto。
• [ auto-flow && dense? ] <grid-auto-rows>? / <grid-template-columns>：设置 grid-template-columns 为指定值。如果使用 auto-flow 关键字，则设置 grid-auto-flow 为 row。如果额外使用 dense 关键字，则自动放置算法将使用 dense 算法。如果省略 grid-auto-rows，则其被设置为 auto。

如下示例中的代码是等效的：

.container {
  grid: 100px 300px / 3fr 1fr;
}

.container {
  grid-template-rows: 100px 300px;
  grid-template-columns: 3fr 1fr;
}

.container {
  grid: auto-flow / 200px 1fr;
}

.container {
  grid-auto-flow: row;
  grid-template-columns: 200px 1fr;
}

.container {
  grid: auto-flow dense 100px / 1fr 2fr;
}

.container {
  grid-auto-flow: row dense;
  grid-auto-rows: 100px;
  grid-template-columns: 1fr 2fr;
}

.container {
  grid: 100px 300px / auto-flow 200px;
}

.container {
  grid-template-rows: 100px 300px;
  grid-auto-flow: column;
  grid-auto-columns: 200px;
}

它还接受更复杂但更方便的语法来一次性设置所有内容。如下示例中的代码是等效的：

.container {
  grid: [row1-start] "header header header" 1fr [row1-end]
        [row2-start] "footer footer footer" 25px [row2-end]
        / auto 50px auto;
}

.container {
  grid-template-areas:
    "header header header"
    "footer footer footer";
  grid-template-rows: [row1-start] 1fr [row1-end row2-start] 25px [row2-end];
  grid-template-columns: auto 50px auto;
}

子元素属性

grid-column-start, grid-column-end, grid-row-start, grid-row-end

该属性通过网格线来设置网格项在网格中的位置。grid-column-start 和 grid-row-start 为网格项起始的线，grid-column-end 和 grid-row-end 为网格项结束的线。

• <line>：指代网格线的数字编号或名称。
• span <number>：该网格项跨越的网格轨道数。
• span <name>：该网格项跨越直到它抵达该名称网格线的下一个网格线。
• auto：表示自动放置、自动跨度或一个默认跨度。

.item {
  grid-column-start: <number> | <name> | span <number> | span <name> | auto;
  grid-column-end: <number> | <name> | span <number> | span <name> | auto;
  grid-row-start: <number> | <name> | span <number> | span <name> | auto;
  grid-row-end: <number> | <name> | span <number> | span <name> | auto;
}