在构建神经网络模型的时候，除了网络结构设计以外，选取合适的优化算法也对网络起着至关重要的作用，本文将对神经网络中常用的优化算法进行简单的介绍和对比，本文部分参考了 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，输入用户名和密码即可登录。

环境信息

frp 是一款高性能的反向代理应用，专注于内网穿透。它支持多种协议，包括 TCP、UDP、HTTP、HTTPS 等，并且具备 P2P 通信功能。使用 frp，您可以安全、便捷地将内网服务暴露到公网，通过拥有公网 IP 的节点进行中转 ¹。

本教程将介绍在具有公网 IP 的服务器和内网路由器上部署 frp 内网穿透服务。本教程涉及到的环境信息如下：

证书申请

frp 证书

在本地创建 cert 目录，将 OpenSSL 配置文件复制到该目录。通常情况下 Linux 系统位于 /etc/pki/tls/openssl.cnf，macOS 系统位于 /System/Library/OpenSSL/openssl.cnf。

运行如下命令生成 ca 证书：

openssl genrsa -out ca.key 2048
openssl req -x509 -new -nodes -key ca.key -subj "/CN=example.com" -days 36500 -out ca.crt

运行如下命令生成服务端证书：

openssl genrsa -out server.key 2048
openssl req -new -sha256 -key server.key \
  -subj "/C=XX/ST=DEFAULT/L=DEFAULT/O=DEFAULT/CN=example.com" \
  -reqexts SAN \
  -config <(cat openssl.cnf <(printf "\n[SAN]\nsubjectAltName=DNS:localhost,IP:127.0.0.1,DNS:*.example.com")) \
  -out server.csr
openssl x509 -req -days 36500 -sha256 \
  -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
  -extfile <(printf "subjectAltName=DNS:localhost,IP:127.0.0.1,DNS:example.com") \
  -out server.crt

运行如下命令生成客户端证书：

openssl genrsa -out client.key 2048
openssl req -new -sha256 -key client.key \
  -subj "/C=XX/ST=DEFAULT/L=DEFAULT/O=DEFAULT/CN=example.com" \
  -reqexts SAN \
  -config <(cat openssl.cnf <(printf "\n[SAN]\nsubjectAltName=DNS:localhost,IP:127.0.0.1,DNS:*.example.com")) \
  -out client.csr
openssl x509 -req -days 36500 -sha256 \
  -in client.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
  -extfile <(printf "subjectAltName=DNS:localhost,IP:127.0.0.1,DNS:example.com") \
  -out client.crt

由于 server.crt 和 client.crt 都是由 ca 签发的，因此他们对于 ca 来说都是合法的。

Nginx 证书

在服务器上运行如下命令安装 acme.sh：

curl https://get.acme.sh | sh -s email=my@example.com

安装脚本将执行如下动作：

1. 在 $HOME 目录创建 .acme.sh 目录并安装 acme.sh。
2. 创建别名 acme.sh 指向 $HOME/.acme.sh/acme.sh。
3. 创建每日定时任务以便更新证书。

以阿里云域名管理为例，在 https://ram.console.aliyun.com/ 页面创建用户，并为用户赋予 DNS 相关管理权限。为用户创建 AccessKey，并设置如下环境变量：

export Ali_Key="xxx"
export Ali_Secret="xxx"

运行如下命令申请证书：

acme.sh --issue --dns dns_ali -d example.com -d *.example.com

frp 配置

服务端

在服务端创建 frp 目录，配置 frps.toml 文件参数如下，更多参数设置请参阅 frp 文档：

bindAddr = "0.0.0.0"
bindPort = 7000
quicBindPort = 7000
vhostHTTPPort = 8080
vhostHTTPSPort = 8443
tcpmuxHTTPConnectPort = 5002

auth.method = "token"
auth.token = "xxx"

transport.tls.certFile = "/path/to/server.crt"
transport.tls.keyFile = "/path/to/server.key"
transport.tls.trustedCaFile = "/path/to/ca.crt"

webServer.addr = "0.0.0.0"
webServer.port = 7500
webServer.user = "xxx"
webServer.password = "xxx"

log.to = "/path/to/frps.log"
log.level = "info"
log.maxDays = 3

在 /etc/systemd/system 路径创建 frps.service 服务，配置内容如下：

[Unit]
Description = frp server
After = network.target syslog.target
Wants = network.target

[Service]
Type = simple
ExecStart = /path/to/frps -c /path/to/frps.toml

[Install]
WantedBy = multi-user.target

运行如下命令管理 frps 服务：

# 自启动 frps
sudo systemctl enable frps

# 启动 frps
sudo systemctl start frps

# 停止 frps
sudo systemctl stop frps

# 重启 frps
sudo systemctl restart frps

# 查看 frps 状态
sudo systemctl status frps

添加如下内容至 Nginx 配置文件中：

server {
    listen 80;
    listen [::]:80;

    server_name *.example.com;

    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;

    server_name *.example.com;

    ssl_certificate /path/to/example.com.cer;
    ssl_certificate_key /path/to/example.com.key;

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_redirect off;
        proxy_ssl_server_name on;

        proxy_set_header Host $host:80;
        proxy_set_header Referer $http_referer;
        proxy_set_header Cookie $http_cookie;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

运行如下命令重启 Nginx：

sudo systemctl restart nginx

客户端

在客户端创建 frp 目录，配置 frpc.toml 文件参数如下，更多参数设置请参阅 frp 文档：

auth.method = "token"
auth.token = "xxx"

user = "xxx"

serverAddr = "frps.example.com"
serverPort = 7000

transport.protocol = "quic"
transport.proxyProtocolVersion = "v2"
transport.tls.certFile = "/path/to/client.crt"
transport.tls.keyFile = "/path/to/client.key"
transport.tls.trustedCaFile = "/path/to/ca.crt"

webServer.addr = "0.0.0.0"
webServer.port = 7400
webServer.user = "xxx"
webServer.password = "xxx"

log.to = "/path/to/frpc.log"
log.level = "info"
log.maxDays = 3

[[proxies]]
name = "example-http"
type = "http"
localIP = "x.x.x.x"
localPort = 80
customDomains = ["example-http.example.com"]

[[proxies]]
name = "example-ssh"
type = "tcpmux"
multiplexer = "httpconnect"
localIP = "x.x.x.x"
localPort = 22
customDomains = ["example-ssh.example.com"]

其中，example-http 采用了通过自定义域名的方式访问内网 Web 服务，更多示例请参考 frp 文档；example-ssh 采用了多个 SSH 服务复用同一端口的方式连接内网 SSH 服务，更多示例请参考 frp 文档。

在 /etc/init.d 路径下创建 frpc 服务，配置内容如下：

#!/bin/sh /etc/rc.common

# 使用 procd
USE_PROCD=1
# 启动顺序
START=95
# 停止顺序
STOP=15

# frpc
FRPC=/path/to/frpc
CONF=/path/to/frpc.toml

start_service() {
    procd_open_instance "frpc"
    procd_set_param command $FRPC -c $CONF
    procd_set_param respawn
    procd_set_param stdout 1
    procd_set_param stderr 1
    procd_set_param pidfile /var/run/frpc.pid
    procd_close_instance
}

service_triggers() {
    procd_add_reload_mount_trigger $CONF
}

运行如下命令管理 frpc 服务：

# 赋予执行权限
chmod +x /etc/init.d/frpc

# 自启动 frpc
/etc/init.d/frpc enable

# 启动 frpc
/etc/init.d/frpc start

# 停止 frpc
/etc/init.d/frpc stop

# 重启 frpc
/etc/init.d/frpc restart

# 查看 frpc 状态
/etc/init.d/frpc status

在服务商中配置 DNS 将 example-http.example.com 和 example-ssh.example.com 解析至 frp 服务器的 IP 地址。

连接

Web

此时，通过浏览器访问 https://example-http.example.com 即可实现访问内网 IP 地址 x.x.x.x 在端口 80 上的 Web 服务。

SSH

此时，通过如下命令即可实现访问内网 IP 地址 x.x.x.x 在端口 22 上的 SSH 服务：

ssh -o 'proxycommand socat - PROXY:frps.example.com:%h:%p,proxyport=5002' test@example-ssh.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 上听（简洁又没广告），但豆瓣推给我的一个播单甚得我意，有点豆瓣书籍和影视年度榜单的味道。随即发了个朋友圈分享了下，一个朋友回复到“这岂不是会天天蹿到你出去玩”，我回复到“出去玩就不听了，出不去才只能听听人家的过过瘾”。这一刻，我有在想是没了出去的勇气，还是连出去的想法都没了？

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

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

什么是微调

微调（Fine-tuning）是深度学习中迁移学习的一种方法，其将现有模型已经学到的知识作为学习新任务的起点。虽然微调表面上是模型训练中使用的一种技术，但它与传统意义上的“训练”截然不同。为了消除歧义，在这种情况下通常将传统意义上的“训练”称为预训练（Pre-training）。¹

与微调类似的另一个概念称之为后训练（Post-training），两者均发生在预训练之后，其目的也都是为了进一步提升模型的效果，通常两者可以理解为相同的概念。从优化的发起人角度出发：当终端用户希望模型可以更好的适配自己的领域知识，则需要进行的操作称之为微调；当模型开发者希望可以更好的将模型与人类的价值、道德和预期保持一致，则需要进行的操作称之为后训练。²

为什么微调

从本质上讲，磨练一个预训练基础模型的能力要比从头开始训练一个新模型更容易，也更省钱，因为预训练已经获得了与当前任务相关的广泛知识。对于具有数百万甚至数十亿个参数的深度学习模型尤其如此，例如在自然语言处理（NLP）领域的大语言模型（LLM）或卷积神经网络（CNN）和视觉转换器（ViT）（用于计算机视觉任务，例如图像分类、对象检测或图像分割等）。

通过迁移学习利用先前的模型训练，微调可以减少获得适合特定用例和业务需求的大模型所需的昂贵算力和标记数据量。例如，微调可用于调整预训练大语言模型的对话语气或预训练图像生成模型的图片样式，还可用于使用专有数据或领域特定的专业知识来补充模型的原始训练数据集。

如何去微调

微调是需要进一步训练模型的技术，模型的权重已经通过先前的预训练得到了更新。使用基础模型的先前知识作为起点，通过在任务特定的较小数据集上进行训练来对模型进行微调。

虽然从理论上讲，任务特定的数据集都可以用于初始训练，但在小数据集上从头开始训练一个大模型可能会存在过拟合的风险：模型可能会在训练示例中学习得到良好的表现，但对新数据的泛化能力却很差。这会导致模型不适合给定的任务，也违背了模型训练的初衷。 因此，微调可以兼具两者的优势：利用对大量数据进行预训练所获得的广泛知识和稳定性，并训练模型对更详细、更具体概念的理解。

微调方法分类

参数角度

从参数角度，我们可以将微调分为全参数微调（Full Fine-tuning）和部分参数微调（Repurposing）：

• 全参数微调：即对模型的所有参数进行微调。这种微调方法通常适用于任务与预训练模型之间存在较大差异的情况。全参数微调需要耗费较大的计算资源和时间，通常可以获得更好的性能，但在数据不足时容易出现过拟合问题。
• 部分参数微调：即仅对模型的部分参数或额外的模型参数进行微调。相比于全参数微调，部分参数微调可以在较少的计算资源和时间的情况下，在一些特定任务上提高模型的性能。

数据角度

从数据角度，我们可以将微调分为监督微调（Supervised Fine-tuning）和无监督微调（Unsupervised Fine-tuning）：

• 监督微调：在进行微调时使用有标签的训练数据集。通过使用这些标签来指导模型的微调，可以使模型更好地适应特定任务。
• 无监督微调：在进行微调时使用无标签的训练数据集。通过学习数据的内在结构或生成数据来进行微调，以提取有用的特征或改进模型的表示能力。

方式角度

从方式角度，我们可以将微调划分为指令微调（Instruction Fine-tuning）和对齐微调（Alignment Fine-tuning）：

• 指令微调：利用格式化的实例以有监督的方式微调大语言模型。通过指令微调不仅可以改善模型的性能，同时也可以增强模型的泛化能力。
• 对齐微调：为了避免大语言模型的幻觉问题，以及同人类的价值观和偏好对齐，提高伦理表现，将人类整合到模型的训练过程中。例如基于人类对结果的反馈，模型通过强化学习从而与人类对齐。

显存消耗

在进行模型微调时我们需要关注显存的消耗，以确保在当前的硬件环境中可以正常进行微调。在进行模型微调时，显存消耗主要同如下因素有关：

• 参数精度：决定了每个参数占用的实际显存大小，例如 FP32（单精度）占用 4 字节，FP16（半精度）占用 2 字节，INT8 占用 1 字节等。
• 模型参数：微调所需显存的基础决定因素，例如微调一个 1B 模型，其参数总量则为 10 亿。
• 梯度：在微调过程中需要存储反向传播计算得到的梯度信息，这部分大小同模型参数相同，精度同训练精度一致。
• 优化器状态：优化器所需的额外信息，例如动量、方差等，不同的优化器占用的显存大小也不尽相同，保守估计为模型参数所需显存的 4 倍。
• 激活值：用于储存前向传播过程中的中间结果，所需显存大小主要受到批大小和序列长度的影响，量级相比前面可以忽略不计。

以全参数微调一个 1B 模型为例，所需的显存大致为 12GB（模型参数：2GB，梯度：2GB，优化器状态：8GB）。在使用部分参数微调时，模型参数本身不变，需要微调的参数会大幅度减少，因此梯度和优化器状态所需的显存也会大幅度减少。在应用一些量化技术后，例如使用 INT8 精度进行微调，则所有部分的显存占用均会相应的减少。

参数高效微调

参数高效微调部分主要参考了 llm-action 项目。

参数高效微调（Parameter-Efficient Fine-Tuning）是指固定大部分预训练模型的参数，仅微调少量或额外的模型参数的微调方法，从而可以极大的降低计算成本。参数高效微调可以从方法的角度可以分为三类 ³：引入新参数（Addition-based），微调部分参数（Selection-based）和重参数化（Reparametrization-based），其中引入新参数又可以划分为适配器方法和软提示方法两种。

在实战过程中我们可以使用 Huggingface 开源的 PEFT 扩展库进行参数高效微调，作为 Huggingface 开源项目其可以与 Transformers，Accelerate 和 Diffusers 等多个开源库无缝衔接使用。在官方文档中我们可以查看支持的微调类型和任务类型。

Prefix Tuning

Prefix Tuning ⁴ 是在输入的 token 前构造与任务相关的 virtual token 作为前缀，在微调的时候仅更新前缀部分的参数。

针对不同的模型结构，构造的前缀也有所不同：

• 自回归结构：添加前缀后，得到 $z = \left[\text{PREFIX}; x; y\right]$。
• 编码器-解码器结构：在编码器和解码器前均添加前缀，得到 $z = \left[\text{PREFIX}; x; \text{PREFIX}’; y\right]$。

作者发现直接更新前缀的参数会导致训练不稳定，因此在前缀之前添加了 MLP 结构，在训练完成后 MLP 部分的参数无需保留，仅保留前缀的参数即可。同时作者也针对前缀使用多少个 virtual token 以及前缀放置的位置对于微调的性能影响进行了相关实验，细节请参考论文原文。

Prompt Tuning

Prompt Tuning ⁵ 可以看作是 Prefix Tuning 的简化版本，其为每个任务定义不同的 Prompt，然后拼接到数据上作为输入。

Prompt Tuning 仅在输入层添加 token，不需要像 Prefix Tuning 那样添加 MLP 结构解决训练问题。通过实验发现，随着模型参数的增加，Prompt Tuning 的效果会逼近全参数微调的效果。

实验还发现，与随机和使用样本词汇表的初始化相比，采用类标签初始化的微调效果更好，但随着模型参数的增加，效果差异会消失。同时 Prompt 的 token 长度在 20 左右可以获得不错的效果，同样随着模型参数的增加，token 长度带来的增益会消失。

P-Tuning

P-Tuning ⁶ 将 Prompt 转换为可学习的 Embedding 层，再通过 MLP+LSTM 结构对 Prompt Embedding 进行处理。

对比 Prefix Tuning，P-Tuning 增加了可微的 virtual token，但仅作用于输入层，没有在每一层都添加。同时，virtual token 的位置也不一定是前缀，其插入的位置是可选的，目的是将传统人工设计的 Prompt 模板中的真实 token 替换为可微的 virtual token。

实验发现随机初始化 virtual token 容易陷入局部最优，因此通过一个 Prompt Encoder（即 MLP+LSTM 结构）对其进行编码可以获得更好的效果。

P-Tuning v2

Prompt Tuning 和 P-Tuning 存在如下问题：

• 缺乏规模通用性：Prompt Tuning 在模型超过 100 亿时可以与全量微调媲美，但对于较小参数的模型与全量微调的效果有很大的差距。
• 缺乏任务普遍性：Prompt Tuning 和 P-Tuning 在一些 NLU 基准测试中表现出优势，但对序列标注任务的有效性尚未得到验证。
• 缺少深度提示优化：在 Prompt Tuning 和 P-Tuning 中，提示仅被插入到输入中，后续插入提示位置的嵌入是通过之前层计算得到。这可能导致插入提示对模型最终效果的影响有限，同时由于序列长度限制可调参数的数量也是有限的。

考虑到上述问题，P-Tuning v2 ⁷ 利用深度提示优化（例如：Prefix Tuning）对 Prompt Tuning 和 P-Tuning 进行改进，类似 Prefix Tuning，其在每一层都加入了 Prompt token 作为输入。

P-Tuning v2 还通过移除重参数化编码器、针对不同任务采用不同提示词长度、引入多任务学习、使用传统分类标签范式等方法进行模型改进。实验表明 P-Tuning v2 可以在不同规模和不同任务中实现与全量微调相媲美的效果。

Adapter Tuning

Adapter Tuning ⁸ 设计了一个 Adapter 模块，并在每个 Transformer 层中插入两个 Adapter 模块，在微调时仅更新增加的 Adapter 模块和 Layer Norm 层中的参数。

Adapter 模块由两个前馈层和一个非线性层组成。第一个前馈层将 Transformer 的输入从 $d$ 维（高维）映射到 $m$ 维（低维），其中 $m \ll d$。通过控制 $m$ 的大小可以限制 Adapter 模块的参数量。中间通过非线性层后，第二个前馈层再将 $m$ 维映射回 $d$ 维作为 Adapter 模块的输出。同时通过 Skip Connection 将 Adapter 的输入也添加到 Adapter 的输出中，这样可以保证即便 Adapter 最开始的参数值接近 0，通过 Skip Connection 的设置也可以保证训练的有效性。

LoRA

神经网络包含很多全连接层，其通过矩阵乘法实现。很多全连接层的权重矩阵是满秩的，针对特定任务微调后，模型的权重矩阵其实具有很低的本征秩（intrinsic rank），因此将参数矩阵投影到更小的空间仍可以得到有效的学习。LoRA ⁹ 的核心思想就是通过低秩分解降低特征矩阵的参数量，从而以较小的参数量来实现大模型的间接训练。

在涉及到矩阵相乘的模块中，在其旁边增加一个新的通路，通过第一个矩阵 $A$ 将维度从 $d$ 降至 $r$，在通过一个矩阵 $B$ 将维度从 $r$ 升回 $d$，其中 $r \ll d$。

在微调时，仅更新上述两个矩阵的参数，再将两条通路的结果相加作为最终的结果，即 $h = W_0 x + B A x$。训练时矩阵 $A$ 通过高斯函数初始化，矩阵 $B$ 初始化为零矩阵，这样训练开始时 $B A = 0$，从而可以确保新的通路对模型的结果没有影响。

在 Attention 模块中，权重矩阵包括用于计算 Q，K，V 的 $W_q$，$W_k$，$W_v$ 以及多头注意力的 $W_o$，实验表明保证权重矩阵的种类数量比增加秩 $r$ 的大小更为重要，通常情况下 $r$ 选择 4，8，16 即可。

IA3

IA3 ¹⁰ 不同于 LoRA 学习低秩权重，而是通过学习向量（$l_k$，$l_v$，$l_{ff}$）对模型的部分参数进行加权实现对一些激活层的抑制或放大，同时优化损失函数以适应少样本学习。

为了对比提升分辨率后的图片质量，我们先下载一张原始的高清图片 ¹，通过 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 开始生成图片。应用局部基于文本的指示的图片和应用局部参考图片生成的图片对比如下：

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

安装 Invoke

从 Invoke 官网下载对应系统的安装包，根据如下步骤完成安装。

1. 运行 Invoke 社区版本，单击 Install 开始安装。
2. 选择安装位置，单击 Next 进行下一步。
3. 选择安装版本，单击 Next 进行下一步。
4. 确认 GPU 情况，单击 Next 进行下一步。
5. 确认安装选项，单击 Install 开始安装。
6. 安装完成，单击 Finish 关闭安装向导。
7. 安装完成后，单击 Launch 启动 Invoke。

用户界面

Invoke 启动后会打开主界面，从启动器的日志不难看出，Invoke 在后台启动了一个 HTTP 服务，用浏览器打开 http://127.0.0.1:9090 可以得到相同的界面：

主界面包含三个区域，分别是：

1. 左侧：用于输入提示词、模型选择和参数设置等。
2. 中间：用于显示生成的图片。
3. 右侧：用于显示生成图片的所需的图层和历史生成的图片等。

左侧

提示词

提示词区域用于输入生成图片提示词。

1. 在下拉菜单中可以选择预设的提示词模板。
2. 在 Prompt 中输入正向提示词，在 Negative Prompt 中输入负向提示词。
3. 也可以将自定义的提示词添加为模板以方便后续使用。

图像

图像区域用于控制生成图片的比例和大小。

1. Aspect 用于设置生成图片的宽高比，Width 和 Height 用于设置生成图片的宽高。
2. Seed 用于设置生成图片的随机数种子，设置相同的随机数种子将在相同的条件下得到一致的图片，这在微调的时候会派上用场。

生成

生成区域用于设置模型和相关参数。

1. Model 用于选择生成图片的模型。
2. Concepts 用于选择进行微调的 LoRA 模型。
3. 高级选项中可以设置图片生成使用的调度器（Scheduler）。调度器负责数据采样，包括采样的步骤数（Steps）和提示词相关性（CFG Scale）等。

中间

中间区域用于查看和调整生成的图片。在后续教程中将会深度介绍如何使用该区域来优化生成的图片。

在上方选项卡中单击 Canvas 可以打开画布，单击 Image Viewer 可打开图片浏览器。

右侧

图板和图片库

图板用于组织和管理用户生成的图像，它提供了一种结构化的方式来高效地分类和访问这些图像。

在图片库中，你可以将图片拖拽到画布中来使用。此外，你还可以在图库中共享、下载和删除图片。

图层

图层区域显示了工作区中用于修改图像的所有活动图层。单击右上角的 + 图标即可添加新图层。你可以创建多个图层并对其进行操作和变换，在生成图像之前进行组合使用。

模型

单击左侧面板的 图标打开模型页面。针对新手用户 Invoke 提供了新手模型包，单击 Starter Models 选项卡，可以看到系统提供了 Stable Diffusion 1.5、SDXL 和 FLUX 三款模型包。根据官方系统环境要求和自己的设备性能选择合适的模型包。

在下载模型前，需在 HuggingFace 的设置页面创建 Token，并将其保存在 Invoke 模型页面的 HuggingFace 选项卡中。本教程选择 SDXL 作为模型包，单击模型包启动下载。模型下载完毕后可以在 Model Manager 中查看已下载的模型。

创作图片

在提示词模板中选择 Environment Art，在 Prompt 中输入如下提示词：

futuristic urban park, neon lighting, raised highways, green spaces, modern architecture

单击模板中的 按钮会开启应用模板后的提示词预览，如下图所示：

可以看到，提示词模板在用户输入的提示词基础上添加了更多的正向和负向提示词。在 Generation 中选择 Juggernaut XL v9 作为生成模型。

在左上角 中输入生成图片的数量，单击 Invoke 开始生成图片。单击左侧面板的 图标打开队列页面，等待中、执行中和已完成的所有任务都将显示在该页面中：

生成的 3 张图片如下所示：

中文测试

为了验证 Juggernaut XL v9 模型对于中文提示词的兼容性，对上述示例和 Environment Art 提示词模板中的提示词整理中英文对照版本如下：

用户的正向提示词使用中文，选择 Environment Art 提示词模板（即提示词模板使用英文），生成的图片如下：

用户的正向提示词使用中文，不选择提示词模板，将 Environment Art 提示词模板的中文提示词补充到用户的正向和负向提示词后，生成的图片如下：

不难看出虽然图片生成的画质不错，但其并未遵循提示词的指令生成（看起来是将中文提示词作为了画风），因此可以判断 Juggernaut XL v9 模型不具备直接使用中文提示词的能力。

在 Linux 中调用一个脚本有多种方式，例如 fork，exec 和 source。其中 fork 为 Linux 系统调用，exec 和 source 均为 bash 内部命令。下面以 parent.sh 和 child.sh 两个脚本演示不同调用方式的区别。

parent.sh 内容如下：

#!/bin/bash

echo "--------------------------------------------------"
echo "Before calling child.sh"
echo "--------------------------------------------------"
echo "PID for parent.sh: $$"

var="parent"
export var

echo "In parent.sh, set var=$var"
echo "In parent.sh, variable var=$var"

echo "--------------------------------------------------"
case $1 in
    exec)
        echo "Call child.sh using exec"
        exec ./child.sh ;;
    source)
        echo "Call child.sh using source"
        source ./child.sh ;;
    *)
        echo "Call child.sh using fork"
        ./child.sh ;;
esac

echo "After calling child.sh"
echo "--------------------------------------------------"
echo "PID for parent.sh: $$"
echo "In parent.sh, variable var=$var"
echo "--------------------------------------------------"

child.sh 内容如下：

#!/bin/bash

echo "--------------------------------------------------"
echo "PID for child.sh: $$"
echo "In child.sh, variable var=$var from parent.sh"

var="child"
export var

echo "In child.sh, set var=$var"
echo "In child.sh, variable var=$var"
echo "--------------------------------------------------"

为了确保脚本可执行，需为其添加执行权限：

chmod +x parent.sh child.sh

fork

fork 通过进程复制来创建一个新进程，新进程称为子进程，当前进程称为父进程。在 fork 之后，子进程拥有父进程的副本，但两者的 PID 不同，同时子进程也拥有父进程的所有属性，例如：环境变量、打开的文件描述符等。

通过 fork 调用是最普遍的方式。在当前终端中通过 ./run.sh 执行时，终端会新建一个子 shell 执行 run.sh，子 shell 执行时，父 shell 仍在运行，当子 shell 运行完毕后会返回父 shell。

运行如下命令进行 fork 方式调用测试：

./parent.sh fork

测试结果如下：

--------------------------------------------------
Before calling child.sh
--------------------------------------------------
PID for parent.sh: 7149
In parent.sh, set var=parent
In parent.sh, variable var=parent
--------------------------------------------------
Call child.sh using fork
--------------------------------------------------
PID for child.sh: 7150
In child.sh, variable var=parent from parent.sh
In child.sh, set var=child
In child.sh, variable var=child
--------------------------------------------------
After calling child.sh
--------------------------------------------------
PID for parent.sh: 7149
In parent.sh, variable var=parent
--------------------------------------------------

exec

exec 与 fork 不同，其不需要开启一个新的 shell 执行子脚本。使用 exec 执行一个新脚本后，父脚本中 exec 后的内容将不再执行。

运行如下命令进行 exec 方式调用测试：

./parent.sh exec

测试结果如下：

--------------------------------------------------
Before calling child.sh
--------------------------------------------------
PID for parent.sh: 9629
In parent.sh, set var=parent
In parent.sh, variable var=parent
--------------------------------------------------
Call child.sh using exec
--------------------------------------------------
PID for child.sh: 9629
In child.sh, variable var=parent from parent.sh
In child.sh, set var=child
In child.sh, variable var=child
--------------------------------------------------

source

source 同 exec 类似，也不需要开启一个新的 shell 执行子脚本。使用 source 执行一个新脚本后，父脚本中 source 后的内容可以继续执行。

运行如下命令进行 source 方式调用测试：

./parent.sh source

测试结果如下：

--------------------------------------------------
Before calling child.sh
--------------------------------------------------
PID for parent.sh: 10274
In parent.sh, set var=parent
In parent.sh, variable var=parent
--------------------------------------------------
Call child.sh using source
--------------------------------------------------
PID for child.sh: 10274
In child.sh, variable var=parent from parent.sh
In child.sh, set var=child
In child.sh, variable var=child
--------------------------------------------------
After calling child.sh
--------------------------------------------------
PID for parent.sh: 10274
In parent.sh, variable var=child
--------------------------------------------------

输入输出文件描述符

在 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"

色域

在当我谈修图时，我谈些什么 - 色彩篇 Part 1 中已经介绍过什么是色彩空间，在显示领域通常会使用 RGB 色彩模型，在印刷领域通常会使用 CMYK 色彩模型。而在颜色感知领域，CIE 1931 色彩空间 则是在设计之初便要求包含普通人眼可见的所有颜色的标准色彩空间。

人类眼睛有对于短、中和长波的感光细胞，色彩空间在描述颜色时则可以通过定义三种刺激值，再利用值的叠加表示各种颜色。在 CIE 1931 色彩空间中，这三种刺激值并不是指对短、中和长波的反应，而是一组约略对应红色、绿色和蓝色的 X、Y 和 Z 的值。X、Y 和 Z 的值并不是真的看起来是红色、绿色和蓝色，而是使用 CIE XYZ 颜色匹配函数计算而来。

在颜色匹配实验中，如下图 ¹ 所示：

受试者通过观察单一光源的颜色和三原色光源的混合颜色是否相同，得到光谱三刺激值曲线如下图 ² 左所示。为了消除负值对数据处理带来的不便，通过转换得到了三个新的值 $X$、$Y$ 和 $Z$ 的曲线如下图 ² 右所示。

在 CIE 1931 色彩空间中，所有可视颜色的完整绘图是三维的，$Y$ 可以表示颜色的明度 ³。$Y$ 表示明度的好处是在给定 $Y$ 值时，XZ 平面将包含此明度下的所有色度。通过规范化 $X$、$Y$ 和 $Z$ 的值：

$$ \begin{aligned} x &= \dfrac{X}{X + Y + Z} \\ y &= \dfrac{Y}{X + Y + Z} \\ z &= \dfrac{Z}{X + Y + Z} = 1 - x - y \end{aligned} $$

色度可以使用 $x$ 和 $y$ 来表示。CIE 1931 的相对色度图 ⁴ 如下所示：

外侧曲线边界是光谱轨迹，波长用纳米标记。不同色域（Color Gamut）标准之间的对比如下图 ⁵ 所示：

对于一个显示设备来说，不可能产生超过其色域的颜色。通常情况下，讨论一台摄影设备的色域并没有意义，但使用什么样的色彩空间进行编码则需要重点关注。

色彩深度

色彩深度，简称色深（Color Depth），即存储一个像素的颜色所需要的位数。若色彩深度为 $n$ 位，则代表一共包含 $2^n$ 种颜色。例如我们常说的真彩色，即 24 位，对应 RGB 三个通道，每个通道 8 位（即 0-255），共可以表示 16,777,216 种颜色。

从上述对比图 ⁶ 中不难看出，色深越大，图像的效果越好，图像内容之间的过度越自然，与此同时占用的存储也会越多。

在视频拍摄中，我们通常说的 8bit 和 10bit 指的是位深（Bit Depth），即每个通道的位数。设备在拍摄素材时，记录更大位数的信息会更有利于后期调色等处理。

在显示器的特性中，我们也经常会遇见 8bit 和 10bit，以及 8bit FRC 这个概念。FRC 是 Frame Rate Control 的缩写，即帧率控制，是一种时间维度的像素抖动算法。以灰度图像为例，如下图所示，当渲染一个图像包含多个帧时，可以让帧在明暗之间进行切换，从而产生中间灰度。

相应的空间维度的像素抖动算法（Dither）如下图所示：

所以，一块原生 10bit 屏幕优于 8bit FRC 10bit 的屏幕优于原生 8bit 的屏幕。

色度抽样

在拍摄视频时，除了 8bit 和 10bit 位深的区别外，我们还经常听到 4:2:2 和 4:2:0 等比值，这代表色度抽样。由于人眼对色度的敏感度不及对亮度的敏感度，图像的色度分量不需要有和亮度分量相同的清晰度，在色度上进行抽样可以在不明显降低画面质量的同时降低影像信号的总带宽。

抽样系统通常用一个三分比值表示：$J : a : b$，其中：

• $J$ 为水平抽样的宽度
• $a$ 为第一行 $J$ 个像素中色度的抽样数量
• $b$ 为第二行 $J$ 个像素中色度的抽样数量

不同的比值色度抽样对比图 ⁷ 如下所示：

动态范围

动态范围（Dynamic Range）是可变信号（例如声音或光）最大值和最小值的比值。在相机中，设置不同的 ISO 会影响到动态范围在记录高光和暗部时的噪点表现。

高动态范围（High Dynamic Range，HDR）相比与标准动态范围（Standard Dynamic Range，SDR）具有更大的动态范围，简而言之 HDR 可以让画面中亮的地方足够亮暗的的地方足够暗。HDR 需要采集设备和显示设备同时支持才能够得以正常的显示，下图 ⁸ 展示了 HDR 和 SDR 从场景采集到显示还原的过程：

最终 SDR 和 HDR 成像的区别如下图 ⁹ 所示（模拟效果）：

在摄影过程中，如下两种方式都可以得到不错的 HDR 照片：

1. 针对 RAW 格式照片，其存储的不同明暗数据已经足够多，针对高光降低一些曝光，暗部增加一些曝光即可获得 HDR 照片。
2. 前期进行包围曝光，即在拍摄时同时拍摄多张具有不同曝光补偿的照片，后期再利用曝光合成技术得到一张 HDR 照片。

在摄像过程中，上述的两种方案就变得不太可行了，如果对于视频的每一帧都保存 RAW 信息会导致视频素材体积过大。此时我们会采用一种名为 Log 曲线的方式对视频的每一帧图像进行处理。

首先我们需要了解一下什么是曝光量（Photometric Exposure）和曝光值（Exposure Value，EV）。曝光量是指进入镜头在感光介质上的光量，其由光圈、快门和感光度组合控制，定义为：

$$ H = Et $$

其中，$E$ 为影像平面的照度，$t$ 为快门的曝光时间。影像平面照度与光圈孔径面积成正比，因此与光圈 $f$ 值的平方成反比，则有：

$$ H \propto \dfrac{t}{N^2} $$

其中，$N$ 为光圈的 $f$ 值。$\dfrac{t}{N^2}$ 这个比例值可以用于表示多个等效的曝光时间和光圈 $f$ 值组合。此比值具有较大的分母，为了方便使用反转该比值并取以 $2$ 为底的对数则可以得到曝光值的定义：

$$ EV = \log_2{\dfrac{N^2}{t}} = 2 \log_2{\left(N\right)} - \log_2{\left(t\right)} $$

在现实中，随着光线强度（类比曝光量）的成倍增加，人眼对于光的感应（类比曝光值）大约成线性增长。同时，摄像机器对于光线强度的记录是线性的，也就是说当光线强度翻倍时，转换后存储的数值也会翻倍。

以 8bit 为例，对于高光部分（7 - 8 档曝光值）会使用 128 位存储相关信息，而对于暗部（0 - 1 档曝光值）则仅使用 8 位存储相关信息，如下图左所示。此时由于高光部分看起来亮度变化并不大，使用的存储位数比暗部多得多，这种非均衡的的存储容易丢失图像的暗部细节。通过对曝光量进行 Log 处理，可以得到均衡的对应关系，如下图右所示。

在真实场景中，各个相机厂商的所搭载的 Log 曲线并不完全相同，都会为了实现某种效果进行调整修改。但整体来说其目的还是为了让每一档曝光值之间存储的信息量大致相同。颜色矫正后和原始应用 Log 曲线的对比图像 ¹⁰ 如下所示：

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;
}