kpmark

浅读 GS-meta

2025-12-10T03:43:47.000Z

GS-meta

前置

MAML，GNN

Abstract

预测分子性质基于有限数据，普遍被视为小样本

但是分子性质与分子关联是多对多，所以需要给予图采样，本文包含三个核心步骤

构建分子性质关系图（MPG）
基于 MPG 重新定义元学习中的任务
使用对比损失调度图采样过程

Introduction

有一篇 Meta-GNN 的论文，Meta-GNN [Guo et al., 2021]

总而言之，是一个在分子性质上应用元学习和图采样的方法工程

Few-shot Learning for Molecules
Episode Scheduler in Meta-learning

Graph Sampling-based Meta-Learning

给出了元学习结构如图

手动构建 MPG，然后进行随机采样，构建任务片段池，用子图采样器计算选择概率，然后选择包含 B 个任务片段的 mini_batch

这里子图是一个数据，一组子图是一个任务，一个 mini_batch 中含有多个任务

Problem Definition

这里有$\mathcal{D}{\text{train}} \ \mathcal{D}{\text{test}}$，包含不同的任务

训练性质和测试性质不相交，即测试中需要预测的完全是新的性质

[!NOTE]
这里，任务和性质一一对应，模型每次输出的是分子在这个性质上的表现

这里元学习的外层循环使用 mini_batch 进行训练，而内侧循环使用了 Episodic Training（情景训练）

[!NOTE]
注意这里的 mini_batch 是对不同任务的划分，和传统的 mini_batch 区别

内层循环，即对于一个单独的任务来说，采样一个训练集$\mathcal{S}_t$和一个测试集$\mathcal{Q}_t$

通常，训练集包含两个类别，分别是活跃与非活跃，每个类别包含 K 个分子，测试集包含 M 个分子

这里情境定义为$E = (\mathcal{S}_t, \mathcal{Q}_t)$

Molecule-Property Relation Graph

构建分子-性质关系图，图表示为$\mathcal{G} = (\mathcal{V}, \mathcal{E})$，表示节点集金和边集的二元组

有两种节点，分别是分子节点$\mathcal{V}_M = \left{ x_m\right}$和性质节点$\mathcal{V}T = \left{ p_t\right}$，边集是二者的笛卡尔积$\mathcal{E} = {e{ij}}$，有两种标签活跃与非活跃

对于一个分子$x_i$，使用一个基于图的编码器获得其嵌入表示

$$
x_i = f_{mol}(x_i)
$$

性质节点的嵌入表示被随机初始化，长度与分子嵌入相同

[!NOTE]
这里的嵌入表示为将图表示为向量

节点特征表示为

$$
h_0^i = \begin{cases}
p_t \ \ \text{if} \ i \in \mathcal{V}_T \
x_i \ \ \text{if} \ i \in \mathcal{V}_M
\end{cases}
$$

数据缺失的边类型使用 unk

这个图很大，所以肯定不可能直接进行预测，所以要采样子图，也就是手动构建任务

对于任务$\mathcal{T}_t$，构建如下情景

$$
\mathcal{S}{t} \sim \mathcal{G}{t}^{S}=\left{\left(x_{i}, e_{i,t},p_{t}\right), y_{i,t}\mid x_{i}\in\mathcal{N}\left(p_{t}\right)\right}_{i=1}^{2K}
$$

简单讲就是某个性质的相邻节点，这里的$\mathcal{N}(p_t)$表示邻居节点

同样，查询集如下

$$
\mathcal{Q}_t \sim \mathcal{G}t^Q = {(x_j, p_t), y{i,t} | x_j \in \mathcal{N}(P_t)}
$$

有情景如下

$$
E_t \sim \mathcal{G}_t = \mathcal{G}_t^s \cup \mathcal{G}_t^Q
$$

这里把两个子图合并，就是整个情景

这里的问题在于，分子和性质的关系被局限于多对一，但是实际通常是多对多关系

在预测同一种分子的新性质时，可以利用其他可用性质，所以需要描述这种多对多关系

$$
\mathcal{G}t^A = { (x_i, e{i,a}, p_a), y_{i,a} | p_a \in \mathcal{N}(x_i) \textbackslash p_t }
$$

$$
\mathcal{G}_t = \mathcal{G}_t \cup \mathcal{G}_t^A
$$

[!NOTE]
为什么要合并训练集和测试集的子图？
因为需要通过图结构（边的关系等）来进行预测，这也解释为什么测试集没有边：只能通过已知节点的关系来推断未知节点性质

使用消息传递机制对采样子图进行迭代更新，这里不仅考虑分子和性质节点之间的关系，分子与分子间也有关系

$$
\alpha^l_{i,j} = \sigma (\text{MLP}(\exp(- | h_i^{l-1} - h^{l-1}_j | )))
$$

这里最外层时 sigmoid 函数，最内部时上一次迭代时两个分子的嵌入表示，结果是两个分子估计出来的连接权重，这个边的类型为mol2mol

首先得跑一遍这个把完整的子图嵌入表示弄好，现在一共有四种边的类型了

然后就可以开始跑 GNN 了，这是内层循环的流程，当前讨论的都是针对某一个任务$\mathcal{T}_t$的

根据以下公式更新节点嵌入

$$
h_i^l = \text{GNN}^{l-1}(h_i^{l-1}, h_j^{l-1}, h_{i,j}^{l-1}, w_{i,j}^l | j \in \mathcal{N}(i))
$$

当更新节点的边不是分子与分子之间是，权重指定为 1

$$
w_{i,j}^l = \begin{cases}
a_{i,j}^l \ \ \text{if} \ e_{i,j} \in \mathcal{E}_{M,M} \
1\ \ \text{otherwise}
\end{cases}
$$

经过 L 次迭代之后，拼接所有节点的最终嵌入，来预测标签

$$
\hat{y}{i,t} = \sigma\left(f{cls}\left(\left[\boldsymbol{h}{i}^{L} \oplus \boldsymbol{h}{t}^{L}\right]\right)\right)
$$

损失计算公式为

$$
\mathcal{L}{t,s}^{cls}(f{(\theta)}) = - \sum_{S_t}(y\log\hat{y} + (1-y) \log (1-\hat{y}))
$$

Subgrapha Sampling Scheduler

子图采样调度器，之前的相关研究中，mini_batch 用随机均匀概率采样 epsiode，这里设计一个更加合理的调度策略，因为不同任务之间是存在依赖关系的

上面的 MPG 是构建子图的方法，在采样时按需构造子图

每个子图仅包含少量分子（设定了是 K 个（训练集，所以对于同一个性质能划分不同的子图，统一性质目标节点的子图应该相关
不同目标性质节点为中心的子图差异应该被放大

记子图采样调度器为$z(\phi)$，使用成对（pairwise）采样策略。对于相同的性质目标$p_t$，两张子图$\mathcal{G}_1 \ \mathcal{G}_2$会被同时采样

具体是，在一个 minibatch 开始的时候，随机采样一个子图候选池$P = \left{(\mathcal{G}_t^{(1)}, \mathcal{G}_t^{(2)})\right}{t=1}^{N{\text{pool}}}$

所有二元组中的子图都是围绕同一个性质节点的，调度器$\mathcal{z}_t$通过一下两个步骤选择出唯一的二元组

计算子图嵌入$\mathcal{g}_t$

$$
\mathcal{g}_t = \mathbf{h}t^{L} + \sigma\left(\sum{i \in \mathcal{V} \setminus {p_t}} \mathbf{h}_i^{L}\right)
$$

这里$\mathbf{h}_t^L$是$p_t$的最终嵌入，求和那一坨是指对子图中除了目标性质节点以为其他所有节点最终嵌入的池化（这里就是求和），这里$\sigma$未作解释，应该是个非线性函数

然后，把$g_t$输入调度器$z_t$，得到选择概率$\eta_t$

$$
\eta_t = z_1\left(g_t + z_2 \left( \sum_{t’ \in P \setminus \mathcal{G}t} g{t’}\right)\right)
$$

这里的$z$都是 MLP（全连接网络），一同构成最终的调度器$z(\phi)$，然后对$\eta_t$用 softmax 就能得到合理的概率了

[!NOTE]
这里的表述没有问题，一个任务有多个子图，最终是多个数值应用 softmax

对于候选池的每一个子图对，用走一套流程，然后最子图对的概率就是二者平均，最终 B 个子图对构成一个 mini_batch

分子类别之间的区别，用到 NT-Xen 损失，这个在对比学习中被广泛使用。统一性质的子图就是正样本对，不同性质的是负样本。一个 mini_batch 中对比损失定义如下

$$
\mathcal{L}^{\mathrm{ctr}} =\frac{1}{B}\sum_{t=1}^{B} -\log \frac{\exp\big(\mathrm{sim}({g}_t^{(1)},{g}t^{(2)})/\tau\big)} {\sum{t’=1,,t’\neq t}^{B}\exp\big(\mathrm{sim}({g}t^{(1)},{g}{t’}^{(2)})/\tau\big)}
$$

这个主要是训练调度器的，但是最终也会影响 GNN 的迭代

sim 啥啥啥是余弦相似度，$\tau$为温度系数

总结一下，上面讲了元学习的任务定义，基于 GNN 的 MPG，然后有 MLP 模块的子图采样器

Training and Testing

终于要开始训练模型了

首先对于性质$t=1$，从候选池拿出 B 个任务对(一个 minibatch)$\left{\left(\mathcal{G}_1^{(1)}, \mathcal{G}_t^{(2)}\right)\right}{t=1}^B$

这里注意了，内层 GNN 使用的任务仍然是一个子图，这里的任务对是用来做对比损失的

关注内层循环(inner-loop)，根据公式 12计算支持集损失，然后做一次梯度下降

$$
\theta’ \leftarrow \theta - \beta_{inner}\nabla_\theta \mathcal{L}^{cls}_{t,S}\left(f(\theta)\right)
$$

这里$\beta$是内循环的学习率，更新完参数之后，再在查询集上计算损失，记为$\mathcal{L}_{t,\mathcal{Q}}^{cls}$，这个在外层循环有用

外层循环公式为

$$
\theta \leftarrow \theta \beta_{outer}\nabla_\theta \mathcal{L}\left( f(\theta’)\right)
$$

这里的损失函数定义为

$$
\mathcal{L}\left(f(\theta’)\right)= \frac1{2B}\sum^B_{t=1} \left({\mathcal{L}^{cls}{t, \mathcal{Q}}}^{(1)} + {\mathcal{L}^{cls}{t, \mathcal{Q}}}^{(2)} \right) + \lambda \mathcal{L}^{ctr}
$$

$\lambda$是一个超参数，这里实际上就是将任务之间的关系量化为一个对比损失函数，然后添加到外循环里

看形式化伪代码

这里还有一个基于 MLP 的采样器需要训练，但是这玩意不好直接求导，所以使用策略梯度方法来训练调度器

$$
\phi \leftarrow \phi + \gamma\nabla_\phi \log P(\eta)(R - b)
$$

这里的 P 是什么东西，R 是什么

测试的时候选一个新性质，然后用辅助性质+内层循环公式 16微调即可

Expriments

GS-Meta 是否优于最先进的基线方法
辅助性质(auxiliary properties)效果如何
episode 和采样调度器有没有用
调度器怎么解释（$z(\phi)$）

文章跑了下列模型

从头学习分子编码器的方法 Siamese，ProtoNet，MAML，TPN，EGNN，InterReLSTM，PAR，本文模型 GS-Meta
预训练分子编码器的防范 Pre-GNN，Meta-MGNN，Pre-PAR，本文模型 Pre-GS-Meta

不同种子下重复 10 次，看均值和标准差

RQ1

模型在所有基线上均有提升，其中给予关系图的方法普遍更好，表明在本文在跑 GNN 的时候考虑分子间关系是有效的

不同数据集效果有差异，可能取决于辅助性质的多少，标签完整度

RQ2

改变训练阶段和测试阶段采样的辅助性质的个数来进行测试，结果如图

同时测试辅助性质缺失标签造成的影响，和增加标签 unk 的影响

RQ3

也就是相关分子，这里测了移除 mol2mol 边的情况 w/o m2m

采样调度器

w/o S，随机 mini_batch，不调度
w/o CL，调度，会影响 GNN 迭代，但是外层循环不使用损失
w/o S, w/o CL，都不用

表现好，耗时短

RQ4

可视化性质关系

性质越相似，越容易出现在同一个 mini_batch 中

复现

在 sider 数据集上跑了一个 10-shot，没有预训练编码器的 GS-Meta

params 如下

{
    "exp_name": "run",
    "dump_path": "dump/",
    "exp_id": "19-04-52.941",
    "gpu": "0",
    "random_seed": 0,
    "data_root": "data",
    "dataset": "sider",
    "mol_num_layer": 5,
    "emb_dim": 300,
    "JK": "last",
    "mol_dropout": 0.1,
    "mol_graph_pooling": "mean",
    "mol_gnn_type": "gin",
    "mol_batch_norm": 1,
    "mol_pretrain_load_path": null,
    "rel_layer": 2,
    "rel_edge_n_layer": 2,
    "rel_top_k": 9,
    "rel_edge_hidden_dim": 100,
    "rel_dropout": 0.1,
    "rel_pre_dropout": 0.1,
    "rel_nan_w": 1.0,
    "rel_nan_type": "nan",
    "rel_batch_norm": 1,
    "rel_edge_type": 1,
    "inner_lr": 0.5,
    "meta_lr": 0.001,
    "weight_decay": 5e-05,
    "second_order": 1,
    "inner_update_step": 1,
    "inner_tasks": 10,
    "episode": 2000,
    "n_support": 10,
    "n_query": 16,
    "n_test_tasks": 200,
    "eval_step": 100,
    "test_batch_size": 128,
    "train_auxi_task_num": null,
    "test_auxi_task_num": null,
    "nce_t": 0.08,
    "contr_w": 0.05,
    "pool_num": 10,
    "task_lr": 0.0005,
    "task_hid_dim": 10,
    "task_t": 1
}

模型描述如下

GSMeta(
  (mol_encoder): GNN_Encoder(
    (gnn): GNN(
      (x_embedding1): Embedding(120, 300)
      (x_embedding2): Embedding(3, 300)
      (gnns): ModuleList(
        (0): GINConv(
          (mlp): Sequential(
            (0): Linear(in_features=300, out_features=600, bias=True)
            (1): ReLU()
            (2): Linear(in_features=600, out_features=300, bias=True)
          )
          (edge_embedding1): Embedding(6, 300)
          (edge_embedding2): Embedding(3, 300)
        )
        (1): GINConv(
          (mlp): Sequential(
            (0): Linear(in_features=300, out_features=600, bias=True)
            (1): ReLU()
            (2): Linear(in_features=600, out_features=300, bias=True)
          )
          (edge_embedding1): Embedding(6, 300)
          (edge_embedding2): Embedding(3, 300)
        )
        (2): GINConv(
          (mlp): Sequential(
            (0): Linear(in_features=300, out_features=600, bias=True)
            (1): ReLU()
            (2): Linear(in_features=600, out_features=300, bias=True)
          )
          (edge_embedding1): Embedding(6, 300)
          (edge_embedding2): Embedding(3, 300)
        )
        (3): GINConv(
          (mlp): Sequential(
            (0): Linear(in_features=300, out_features=600, bias=True)
            (1): ReLU()
            (2): Linear(in_features=600, out_features=300, bias=True)
          )
          (edge_embedding1): Embedding(6, 300)
          (edge_embedding2): Embedding(3, 300)
        )
        (4): GINConv(
          (mlp): Sequential(
            (0): Linear(in_features=300, out_features=600, bias=True)
            (1): ReLU()
            (2): Linear(in_features=600, out_features=300, bias=True)
          )
          (edge_embedding1): Embedding(6, 300)
          (edge_embedding2): Embedding(3, 300)
        )
      )
      (batch_norms): ModuleList(
        (0): BatchNorm1d(300, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (1): BatchNorm1d(300, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): BatchNorm1d(300, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (3): BatchNorm1d(300, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (4): BatchNorm1d(300, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
  )
  (relation_net): TaskRelationNet(
    (pre_dropout): Dropout(p=0.1, inplace=False)
    (task_emb): Embedding(27, 300)
    (node_layer0): NodeUpdateNetwork(
      (neigh_linear): Linear(in_features=300, out_features=300, bias=True)
      (root_linear): Linear(in_features=300, out_features=300, bias=True)
      (edge_emb): Embedding(4, 300)
      (batch_norm): BatchNorm1d(300, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (dropout): Dropout(p=0.1, inplace=False)
      (act): LeakyReLU(negative_slope=0.01)
    )
    (edge_layer0): EdgeUpdateNetwork(
      (sim_network): Sequential(
        (conv0): Conv2d(300, 200, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (norm0): BatchNorm2d(200, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu0): LeakyReLU(negative_slope=0.01)
        (drop0): Dropout2d(p=0.1, inplace=False)
        (conv1): Conv2d(200, 100, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (norm1): BatchNorm2d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu1): LeakyReLU(negative_slope=0.01)
        (drop1): Dropout2d(p=0.1, inplace=False)
        (conv_out): Conv2d(100, 1, kernel_size=(1, 1), stride=(1, 1))
      )
    )
    (node_layer1): NodeUpdateNetwork(
      (neigh_linear): Linear(in_features=300, out_features=300, bias=True)
      (root_linear): Linear(in_features=300, out_features=300, bias=True)
      (edge_emb): Embedding(4, 300)
      (batch_norm): BatchNorm1d(300, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (dropout): Dropout(p=0.1, inplace=False)
      (act): LeakyReLU(negative_slope=0.01)
    )
    (edge_layer1): EdgeUpdateNetwork(
      (sim_network): Sequential(
        (conv0): Conv2d(300, 200, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (norm0): BatchNorm2d(200, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu0): LeakyReLU(negative_slope=0.01)
        (drop0): Dropout2d(p=0.1, inplace=False)
        (conv1): Conv2d(200, 100, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (norm1): BatchNorm2d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu1): LeakyReLU(negative_slope=0.01)
        (drop1): Dropout2d(p=0.1, inplace=False)
        (conv_out): Conv2d(100, 1, kernel_size=(1, 1), stride=(1, 1))
      )
    )
    (graph_pooling): Sequential(
      (0): Linear(in_features=300, out_features=150, bias=True)
      (1): ReLU()
      (2): Linear(in_features=150, out_features=300, bias=True)
    )
    (classifier): Sequential(
      (0): Linear(in_features=600, out_features=300, bias=True)
      (1): BatchNorm1d(300, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU()
      (3): Linear(in_features=300, out_features=1, bias=True)
    )
  )
)

子图调度器结构如下

TaskSelector(
  (z1): Sequential(
    (0): Linear(in_features=300, out_features=10, bias=True)
    (1): ReLU()
    (2): Linear(in_features=10, out_features=1, bias=True)
    (3): Tanh()
  )
  (z2): Sequential(
    (0): Linear(in_features=300, out_features=300, bias=True)
    (1): ReLU()
    (2): Linear(in_features=300, out_features=300, bias=True)
  )
)

训练 loss，测试得分如下图

最终得分 83.75，与论文基本一致

浅读 MAML

2025-12-01T03:43:47.000Z

Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks

Abstract

模型无关的元学习（meta-learning）算法，兼容所有基于梯度下降训练的模型，适用于分类、回归和强化学习

通过对模型进行多任务训练（a variety of learning tasks），用少量训练样本解决新任务？

使用少量数据和训练就能在任务上得到很好的泛化性能

简单来说，MAML 赋予模型学习“如何学习”的能力，是的其在面对新任务时能够快速适应

Intro

算法核心：训练模型的初始参数，是的模型在之后遇到新的任务时，通过少量数据就能获得最大性能

与先前提出的元学习算法不同，此算法不增加学习参数数量，不约束模型架构

从特征学习的角度，MAML 算法过程，可以被视为构建了一种广泛使用于多种模型的内部表征（Internal representation）

从动力系统角度，这个学习过程可以被视为最大化新任务损失函数对参数的敏感性，只要敏感度够高，参数的微小变化就能使任务损失大幅提升

本文评估结果：监督分类任务中，MAML 优于专门为小样本学习的最先进方法（17 年），在回归问题和强化学习中，性能远超直接使用预训练模型进行初始化的传统方法

[!NOTE]
这里的显著优于适用于存在任务变异性的场景中强化学习进程的预训练初始化，对于普通的回归问题，原文为（can also be readily applied to）

Model-Agnostic Meta-Learning

这玩意通常在小样本学习的理论框架下

Meta-Learning Problem Set-Up

考虑一个模型$f$，将观测$x$映射到$a$，因为框架是通用的，所以需要通用任务概念

$$
\mathcal{T} = \left{ \mathcal{L}(\mathbf{x}_1, \mathbf{a}_1, \ldots, \mathbf{x}_H, \mathbf{a}_H),\ q(\mathbf{x}1),\ q(\mathbf{x}{t+1} \mid \mathbf{x}_t, \mathbf{a}_t),\ H \right}
$$

其中，包含一个损失函数$\mathcal{L}$，初始观测分布$q(\mathbf{x}1)$，转移分布$q(\mathbf{x}{t+1} \mid \mathbf{x}_t, \mathbf{a}_t)$，和情节长度$H$

独立同分布问题中，长度$H = 1$，模型在每个时间步选择一个$a$来生成长度为$H$的样本，损失函数提供任务特定的反馈

在元学习场景中，考虑一个任务分布$p(\mathcal{T})$，模型需要尽快适应这个新的分布

A Model-Agnostic Meta-Learning Algorithm

模型在新任务上使用基于梯度的规则进行微调，我们使用同样的方式学习一个模型，目标是找到对任务变化敏感的模型参数

这里的参数指的是内部参数，而不是超参数

有一下两个假设

模型由$\theta$参数化
损失函数足够平滑

这里的损失通过任务的$\mathcal{L}$来计算，而$\theta$指代模型的内部参数，通过梯度下降更新

$$
\theta’i = \theta - \alpha \nabla{\theta}\mathcal{L}_{\mathcal{T}i}(f{\theta})
$$

本节考虑一次梯度更新的情况，多次也行，反正就是计算单个任务的较优内部参数

训练方式就是优化其在不同任务上对应的性能，即最小化代价函数

$$
\min_{\theta} \sum_{\mathcal{T}i \sim p(\mathcal{T})} \mathcal{L}{\mathcal{T}i} (f{\theta_i’}) = \sum_{\mathcal{T}i \sim p(\mathcal{T})} \mathcal{L}{\mathcal{T}i} (f{\theta - \alpha \nabla_\theta \mathcal{L}_{\mathcal{T}_i}(f_\theta)})
$$

通过随机梯度下降（SGD）执行优化迭代如下

$$
\theta \leftarrow \theta - \beta \nabla_{\theta} \sum_{\mathcal{T}{i} \sim p(\mathcal{T})} \mathcal{L}{\mathcal{T}{i}}(f{\theta_{i}^{\prime}})
$$

有形式化算法

对于单个损失的计算，使用了验证集和训练集

这里的梯度更新实际上涉及梯度的梯度，所以需要进行一次额外的反向传播，大多数库都支持

也有一种省略该传播的近似

实际应用和实现先不看了

浅读 Flatten Transformer

2025-10-30T03:43:47.000Z

Flatten Transformer

Abstract

二次计算复杂度

来源于 Dot-Product Attention 计算

$$
\text{Attention}(Q, K, V) = \text{Softmax}(\frac{QK^T}{\sqrt{d_k}})V
$$

Q，K 分别是 N X d 矩阵，导致计算注意力的时候时间复杂度为$n^2$d

Linear attentioin 通过映射函数近似 Softmax 操作，提供线性复杂度

要么性能显著下降，要么因为 mapping funciton 引入额外计算开销

引入了一种简单有效的映射函数和一个高效的秩恢复模块

https://github.com/LeapLabTHU/FLatten-Transformer。

[!NOTE]
查找，其他线性注意力机制

Intro

线性注意力

通过改变激活函数和映射函数替代 Softmax，使得矩阵计算顺序调换

先计算$K^TV$改变计算顺序，将复杂度变成$O(nd)$

有更大的感受野（receptive field）和吞吐量

global reveptive field 指 Attention 建立联系的范围

针对 Transformer 在 CV 领域的应用，相较于 CNN，存在计算复杂度为$O(n^2d)$的矩阵运算

linear attention 通过**适当的近似(proper approximation)**解耦了 Softmax，但是还是有性能下降和额外计算开销

铺垫结束

本文提出模块 Focused Linear Attention

用 dual-pronged analysis 研究了线性注意力下降的因素

现有的线性注意力模块的注意力权重相对平滑，缺乏对特征重点的关注能力
- 使用 simple mapping function 调整查询和键的特征方向
- rank restoration module，秩恢复模块，恢复矩阵的秩，保证特征多样性

总的来说，就是想办法替代 softmax

[!NOTE]
从从原理角度探究，为什么线性注意力机制会让前后关联注意力下降，特征多样性减小

Vision Transformer

[!NOTE]
看一眼相关文献

Transformer 在 CV 中有广泛应用

计算复杂度很高，所以限制了直接应用（CV 中输入很多，CNN 有相关优化

Vision Transformer 合并相邻像素降低分辨率
PVT 稀疏注意力
DAT 设计可变形注意力模块
Swin Transformer 分割输入为独立窗口
NAT 为所有查询设计独立的注意力标记

CMT 结合 Transformer 和 convolution（卷积）算子
ACmix 恭喜那个卷积和自注意力开销

MobileFormer 维护卷积和 Transformer 两条路径
Dyn-Percriver 使用动态早退机制（dynamic early exiting
MobileViT 结合 MobileNet 和 Transformer

以上所有算法最终都依赖于 softmax，复杂度仍为$n^2 d$

Linear Attention

这些方法就是试图替换 Softmax，这样交换矩阵计算顺序，复杂度即为$nd$

Performer 使用正交随机特征
Efficient Attention 单独对 Q 和 K 应用 Softmax
Nyströmformer 和 SOFT 通过矩阵分解近似完整的自注意力矩阵
Hydra Attention 使用余弦相似度替换 Softmax，使用 Hydra 技巧将计算复杂度降低到$O(Nd)$
EfficientVit 使用深度可分离卷积来提升线性注意力的局部特征提取能力
Castling-ViT 提出了线性角度核来衡量每个 Q 和 K 之间的谱相似性

上面那些都有点 🌽，所以本文提出 focused linear attention，计算复杂度更低，性能超过 Softmax（？

Preliminaries

Vision Transformer and Self-Attention

ViT（Vision Transformers)中，给定 n 个 token，$x \in R^{N \times C}$有以下公式

$$
Q = xW_Q,K = xW_K, V = xW_V\
O_i = \sum_{j=1}^N \frac{\text{Sim}(Q_i,K_j)}{\sum^N_{j=1}\text{Sim}(Q_i, K_j)}V_j\
\frac{\text{Sim}(Q_i,K_j)}{\sum^N_{j=1}\text{Sim}(Q_i, K_j)}V_j=\text{Attention}(Q, K, V) = \text{Softmax}(\frac{QK^T}{\sqrt{d_k}})V
$$

其中，三个$W$是$R^{C \times C}$的矩阵，是需要训练求得的参数

$\text{Sim(·,·)}$是相似度函数，ViT 主要采用 Softmax 注意力，即$\text{Sim}(Q,K) = \exp(\frac{QK^T}{\sqrt{d}})$

注意这里的$Q_i$表示矩阵的某一行（某一个向量

注意力需要计算所有 Q-K 对，导致$N^2$的复杂度

[!NOTE]
Softmax 的核心思想在于将一个 K 维向量压缩成一个 K 维的概率函数

[!NOTE]
先前的工作主要通过 designing sqarse global attention pattern（设计稀疏全局注意力模式）或 applying smaler attention windows（应用较小注意力窗口）
受到额外注意力影响、或牺牲长距离依赖关系的能力

Linear Attention

这种方法引入新的核函数替代 Softmax

$$
\text{Sim}(Q,K) = \phi(Q)\phi(K)^T\
O_i = \sum^N_{j=1} \frac{\phi(Q_i)\phi(K_j)^T}{\sum^N_{j=1}\phi(Q_i)\phi(K-J)^T}V_j\
O_i = \frac{\phi(Q_i)(\sum^N_{j=1}\phi(K_j)^TV_j)}{\phi(Q_i)(\sum^N_{j=1}\phi(K_j)^T)}
$$

这样变换后，矩阵计算顺序变化，复杂度变为$N$

然而，核函数太简单了性能不够，太复杂了有额外计算开销

Focused Linear Attention

Focus ability

Softmax 本质上是一种非线性重加权机制，其产生的注意力在特定区域非常集中

[!NOTE]
补充 Softmax 在 Transformer 中的作用
其实 Softmax 除了在注意力机制中起作用，原本在解码器的最后一层也要作为分类器的一部分计算概率分布
这里仅讨论其在编码器线性注意力中的作用
注意力机制首先为每个 token 计算一个查询向量 Q 和键向量 K，通过二者点积，可以计算出表示两个 token 之间相关性的原始得分矩阵
这些得分非常抽象，根据原始 token 和参数莫名其妙就算出来了，无法直接表示所谓的注意力
所以 Softmax 对矩阵的每一行都应用，将这一行归一化为一个总和为 1 的概率分布，且权重分布会非常清晰，之后这些权重分布会在和 V 矩阵点乘，表示值的加权求和

线性注意力的分布较为平滑，其输出更接近所有特征的均值

下图是 DeiT-tiny 模型下，Softmax、linear 和 focus linear 的对比，红色色块的特征被用作查询

[!NOTE]
尝试复现？

$$
\text{Sim}(Q_i, K_j) = \phi_p(Q_i)\phi_p(K_j)^T\
where \ \phi_p(x) = f_p(ReLU(x)), f_p(x) = \frac{||x||}{||x^{**p}||}x^{**p}
$$

上式中的$f_p$即为本文提出的聚焦函数

$x^{**p}$表示 x 的逐元素 p 次幂运算

首先使用从前线性注意力模块的算法，使用 ReLU 算法保证特征的非负性和分母有效性

得到结论：特征经过该映射后范数保持不变（与 Softmax 变换就不改变范数 00 上述结论的目的，是为了表明该操作仅调整了该特征的方向，与其他线性注意力中的成功核函数设计理念保持一致

由于其只改变特征向量的方向而非大小，所以其提升性能的根源在于对语义方向的优化

[!NOTE]
$$
|x| = \sqrt{x_1^2 + x_2^2 + … + x_n^2}
$$

在此基础上，可以证明这里提出的映射函数$f_p$能够实际影响注意力的分布

[!NOTE]
有严格的证明，但是这里先不看 🙈

通过选择合适的 p 值，该文章提出的函数可以显著增强注意力的区分度，从而恢复与原始 Softmax 函数相似的尖锐注意力分布

通过图片可以看出，$f_p$可以将每个特征向量拉向最接近的坐标轴，p 值决定这种拉动的强度，也就是提高组内特征的相似性，降低组间特征的相似性

Feature diversity

除聚焦能力外，特征多样性也是限制线性注意力的关键因素

潜在原因可能与注意力矩阵的相关。以 DeiT-Tiny 中$N=14 \times 14$的 Transformer 为例，其标准注意力矩阵具有满秩特性

然而，线性注意力中的注意力矩阵存在理论上限，由每个注意力头中的 N 和 d 共同决定（这里是线性代数推导

$$
\text{rank}(\phi(Q)\phi(K)^K)\le\min{\text{rank} (\phi(Q)), \text{rank}(\phi(K))} \le \min { N, d}
$$

在常见的 ViT 中，d 通常小于 T，注意力矩阵的上限被限制了，所以注意力权重的同质化不可避免的导致聚合之后的特征出现相似性

上图可以看出，Linear 使得注意力矩阵的许多行非常相似

所以这篇论文提出了如下公式，添加了一个 DWC（深度可分离卷积）模块

$$
O = \phi(Q)\phi(K)^TV + \text{DWC}(V)
$$

DWC 可以被视为一种特殊的注意力机制，在这种机制中，每个 Q 关注空间中的几个相邻特征，而非所有特征 V

这样，即使两个查询对应的线性注意力相同，其 DWC 不同，导致其输出仍然不同

也可以从矩阵的秩的角度表示：

$$
O = (\phi(Q)\phi(K)^T + M_{\text{DWC}})V = M_{eq}V
$$

这里$M_{DWC}$表示深度卷积函数对应的稀疏矩阵，$M_{eq}$为等效的全注意力映射。因为$M_{DWC}$有成为满秩矩阵的潜力，所以这个做法极大的提升线性注意力的性能。

Focused linear attention module

上文已经成功提出了一种聚焦函数，可以用来替代 Softmax 函数中的基函数

这里结合 DWC，提出新的线性注意力模块，即聚焦线性注意力

$$
O = Sim(Q,K) = \phi_p(Q)\phi_p(K)^TV + \text{DWC}(V)
$$

优点

具备与线性注意力相同的低计算复杂度
具备与 Softmaz 注意力相当的高表达能力

此外，该模型还具有适应更大感受野和不同模型架构的潜力，此论文已经在 DeiT、PVT、PVT-v2、Swin Transformer 和 CSwin Transformer 中进行了验证实验

剩下部分暂时掠过

浅读 Attention is all your need

2025-10-03T03:43:47.000Z

Transformer

Abstract

主流 Seq2Seq 模型，基于 CNN 和 RNN，包含 encoder 和 decoder 的复杂模型，通过注意力机制连接解码器和编码器

Transformer，摆脱 CNN 与 RNN，仅使用注意力机制

好训练，精度高，可泛化

Intro

当前状态依赖于上一次计算得到的状态，因此每个 token 无法进行并行计算，限制模型性能

Transformer 结构避免循环，通过 Self-attention 让序列中的每一个 token 都与其他所有 token 直接建立联系

模型第一层直接接收到的输入时序列中所有 token 嵌入向量（Embedding Vectors 和位置编码（Positional encoding 组成的矩阵

平均注意力加权可能导致有效分辨率降低，但是可以通过 Multi-Head 抵消这种负面影响

每个特征因为混入了上下文联系信息，导致其本身的细节特征在一定程度上被模糊

recurrent attention instead of sequence-aligned recurrence

前者是 transformer 采用的，计算注意力矩阵的方式，后者是 RNN 使用的，步进迭代当前状态的

Model Architecture

Encoder and Decoder

Encoder 包含 6 个完全相同的层，每层有一个 Multi-Head Attention 和前馈全连接，两个子层都做了残差连接和归一化(Add and Norm)

这个 Add & Norm 有点神秘

这里的 FFN，类似针对矩阵的全连接计算（这里因为上下文相关，所以不会混合位置信息

Decoder 同样由三个子层组成，这里每层第一个 self-attention 加上了掩码，这个需要结合预测和训练的不同行为来理解

训练时，给 Decoder 的输入时正确答案，为了不让模型知道后续的正确答案（因为预测时不知道），需要掩码进行修饰
训练时，Decoder 的输入时自回归的输出，每一次输出的内容时与之前的输出有联系

Attention

query，key，value 三个向量，映射成一个 output。output 是通过对 value 加权求和算出来的。权重时通过 query 和 key，用 compatibility function 算出来的

这里的 cpmatibility function 就是 Scaled Dot-Product Attention 算法

[!NOTE]
这里的三个向量是原来的输入点乘了神秘参数

Scaled Dot-Product Attention

实际上就是

$$
Attention(Q,K,V) = softmax(\frac{QK^T}{\sqrt{d_k}})V
$$

Q 和 K 的转置点乘，得到 Q 和 K 的相关性值，除以纬度放缩，然后 softmax 输出一个权重矩阵，拿这个矩阵和 V 相乘，得到 V 得加权平均

这个加权平均矩阵，每一个向量都融合了输入矩阵的特征

[!NOTE]
论文中的模型 self-attention 计算相关性的方式是 Dot-product，但是也可以使用矩阵和的形式 Additive，论文中提到这种形式可能在不进行缩放的情况下优于 Dot-product，所以这里会使用$\sqrt{d_k}$进行缩放
实际上 QK 两个向量都是用来计算 self-attention 中相关性引出的，其点积结果就是 Dot-product 的结果
这个结果表明了输入矩阵中的向量两两之间关系的权重，这里再乘以 V 向量就相当于求加权和，得到的结果就是矩阵中某个向量与其他矩阵的关系分数

Multi-Head Attention

就是通过不同的参数得出不同版本的 QKV，然后分别计算相关性得分

注意每个版本的 QKV 得到的都是一个向量，将这些向量拼接成一个矩阵，然后与可学习参数$W^o$点乘，得到最终 Multi-Head Attention 的计算结果

FFN

两个线性全连接，中间夹着一个 ReLU

FFN（前馈层，又叫 MPL（多层感知 🐔

Train

优化器使用 Adam

Code

import torch.nn as nn

# 使用 Transformer base 参数
d_model = 512      # 嵌入维度
N = 6              # 编码器和解码器的层数
h = 8              # 多头注意力的头数
d_ff = 2048        # 前馈神经网络的隐藏层维度
dropout = 0.1      # Dropout 概率

model = nn.Transformer(
    d_model=d_model,
    nhead=h,
    num_encoder_layers=N,
    num_decoder_layers=N,
    dim_feedforward=d_ff,
    dropout=dropout,
    batch_first=True
)

print(model)

Transformer(
  (encoder): TransformerEncoder(
    (layers): ModuleList(
      (0-5): 6 x TransformerEncoderLayer(
        (self_attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (linear1): Linear(in_features=512, out_features=2048, bias=True)
        (dropout): Dropout(p=0.1, inplace=False)
        (linear2): Linear(in_features=2048, out_features=512, bias=True)
        (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (dropout1): Dropout(p=0.1, inplace=False)
        (dropout2): Dropout(p=0.1, inplace=False)
      )
    )
    (norm): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
  )
  (decoder): TransformerDecoder(
    (layers): ModuleList(
      (0-5): 6 x TransformerDecoderLayer(
        (self_attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (multihead_attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (linear1): Linear(in_features=512, out_features=2048, bias=True)
        (dropout): Dropout(p=0.1, inplace=False)
        (linear2): Linear(in_features=2048, out_features=512, bias=True)
        (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (norm3): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (dropout1): Dropout(p=0.1, inplace=False)
        (dropout2): Dropout(p=0.1, inplace=False)
        (dropout3): Dropout(p=0.1, inplace=False)
      )
    )
    (norm): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
  )
)

东莞和 vivo 和 aigc

2025-08-22T03:43:47.000Z

欢迎参加中国高校计算机大赛 · AIGC 创新赛

吃了第二届参加人数少的福利，我们这种做了一个月的毛胚项目也能进国赛

vivo 给参与国赛的每个队伍提供了夏令营集训和 vivo vision 发布会暨影像盛典的名额，于是兴高采烈的和队友跑跑了两趟东莞（只是可惜去年答辩是在天津，今年去不了

夏令营

vivo 邀请我们参观了园区和他们的自动化车间

以前只在电视和报道中看过自动化车间，这次能够亲身感受自动化车间的工作氛围实在幸运

可惜 vivo 不让给设备拍照

然后上了好多课，听了好多讲座，参加了模拟答辩

深切感觉到自己的项目能够挤进国赛有多么不可思议

其他团队的项目，要么是策划已久，方案齐全详尽的软件计划，要么是他们实验室的科研成果转化

相比之下我们的项目就很苍白了，正紧开发也就是不到一个月，正儿八经参与开发的也就两个人，PPT 也非常简陋，演示视频效果也不好……

于是老实回家打磨软件，写屁屁踢

发布会

因为暴雨和航空管制耽误半天之后，总算是又飞到了东莞

vivo 提前给了伴手礼，有一个挎包，一个水杯，一个创作者日记和一盒明信片

隔天去会场参加正式的发布会

会场在东莞体育馆，中心看台被改成了发布会场地，四周的场馆做成了展馆

有 vivo vision 的展台，vivo 自家摄影比赛的展台，和茶歇（重点

（拿到一杯他们家的 🍊 美式，太甜了

正式的发布会上，其实大多数功能直接看隔壁 🍎 的 vision pro 就能知道个大概，比较值得一提的就是重量达到了 398g，很轻便

vivo 自己也知道这个产品的成熟度远没到可以售卖的阶段，所以发布的是所谓探索版，仅仅开放了线下授权店的体验

但是要我说他这个支持 windows 电脑串流和安卓手机投屏已经赢了 vision pro 太多了

现场没开放体验，但是我们第二天有去园区体验的机会

vivo 的园区正好在 30 周年纪念活动，除了这些 vivo vision 的体验也有其他展览（比如把手机冻进冰块的神必操作

碍于时间限制没法完整体验完所有流程，也不能看完 vivo park 的演出，但是我们仍然可以到二楼完整体验一下 vivo vision 的功能

vivo 为戴眼镜的朋友提供了度数测量和镜片匹配服务

（虽然但是，我感觉他测量的并不是很准，我和队友两个人的镜片效果都差强人意）

在工作人员的帮助下，我把 vision 支持的功能基本都体验了一遍

首先通过 vision 扫描我的头型，选择合适我的面罩

然后是视频收看，他提供了一段常规的视频，但是可以通过头显进行全屏放映

实际体验下来非常类似电影的观感，我认为是这其中最让人惊艳的功能了

之后看了有 180° 和 270° 的视频，每个 VR/MR 的必吃环节，不多赘述

所有应用窗口都是可以自定义在空间各处的，体验很不错，但是官方宣传里说是打工牛马专属工具……

既然是 MR，肯定得有增强现实的部分，我没有体验他给出的神秘小音游，而是选择了一段交互演出，大致还是和虚拟人物互动，实际上现实的部分不多

当时给出的演示地点空间不大，不然可以走动观赏，据工作人员说可以看到建模很精密的地方，但是我持怀疑态度

总体来讲，我觉得 vision 作为影音设备的功能是非常强大的

但是手眼交互这块，说实话没有达到发布会给我的预期

然后 MR 交互也差强人意

期待正式版这些问题能够得到改进

决赛答辩

发布会之后，我们从原来的酒店转移到了东莞迎宾馆

给我干那来了，这还是国内吗.jpg

我是真没想到还能住上一次五星级酒店，企业赞助的比赛就是有底气，你说是吧 xx

止步国二，但是结果已经超出我的预料

从五月的一个想法，到小学期的正式开发，再到八月的夏令营和包装

满打满算一个多月的开发，有过因为赶进度一天只吃一口饭，也因为 ddl 之前的 bug 红温过，在模拟答辩被其他组比的一无是处，在电脑前对着不擅长的 ppt 抓耳挠腮

我们不像其他队伍有着祖传代码和科研底蕴，也没有博士生研究生过来代打。他们有产品，开发，UI，答辩，而我们正经参与开发的就两个大二，还要靠着自己稀碎的审美做屁屁踢剪视频

但是第一次，在正式比赛的答辩中，我没有紧张到手无足措

从需求，到架构，到开发，到美化，到包装

每一行代码，每一行字，每一处技术栈我都深度参与，没有 AI 给的乱七八糟的屎山，我头一次对每一处内容都有把握

这个结果，我心满意足

感谢队友，没有他的端侧我们甚至进不了决赛，感谢自己，没有在最红温的时候撂挑子不干

感谢焦头烂额的那一个个日日夜夜

修改于 8 月 25 日晚，东莞迎宾馆
kpmark

Tauri 安卓踩坑笔记

2025-07-17T03:43:47.000Z

Tauri 安卓踩坑日记

简单记录一下使用 Tauri 2.0 开发安卓应用踩的小坑

打包签名 apk

官网上其实写的很清楚，但是就是有两个 🐖 眼睛瞎了

首先你要有一个密钥库，可以通过 Android Studio 生成密钥，也可以用 keytool 生成，这里我们通过命令行使用 keytool

1	keytool -genkey -v -keystore $env:USERPROFILE\upload-keystore.jks -storetype JKS -keyalg RSA -keysize 2048 -validity 10000 -alias upload

你的 keytool 安装在 Android Studio 附带的 JDK 中，例如C:\\Program Files\\Android\\Android Studio\\jbr\\bin\\keytool.exe

然后在[project]/src-tauri/gen/android/keystore.properties位置创建文件，这个文件包含对你密钥库的引用信息

注意你的密钥库和 keystore.properties 都应该是私密的

最后，我们只需要在 Gradle 中配置签名选项即可

在**[project]/src-tauri/gen/android/app/build.gradle.kts**文件中，添加如下引用

1 2	import java.util.Properties import java.io.FileInputStream

在buildTypes代码块之前的signingConfigs 中添加release代码块

signingConfigs {
    create("release") {
        val keystorePropertiesFile = rootProject.file("keystore.properties")
        val keystoreProperties = Properties()
        if (keystorePropertiesFile.exists()) {
            keystoreProperties.load(FileInputStream(keystorePropertiesFile))
        }

        keyAlias = keystoreProperties["keyAlias"] as String
        keyPassword = keystoreProperties["keyPassword"] as String
        storeFile = file(keystoreProperties["storeFile"] as String)
        storePassword = keystoreProperties["storePassword"] as String
    }
}

buildTypes {
    ...
}

最后在buildTypes块的release中使用新的配置

buildTypes {
    getByName("release") {
        signingConfig = signingConfigs.getByName("release")
    }
}

看上去很简单，但是就是有 🐖 分不清src-tauri\gen\android\build.gradle.kts和src-tauri\gen\android\app\build.gradle.kts

注意着两个文件同名但路径不同，功能也不同

使用 HTTP 客户端插件

这里官网的文档说的不是很详细

我们使用的是 JavaScript API 版本，通过

1	npm run tauri add http

安装插件

在官方文档中，给出的配置允许访问的 URL 的配置文件如下

// src-tauri/capabilities/base.json
{
  "permissions": [
    {
      "identifier": "http:default",
      "allow": [{ "url": "https://*.tauri.app" }],
      "deny": [{ "url": "https://private.tauri.app" }]
    }
  ]
}

但是我们找到src-tauri/capabilities中，并没有发现base.json文件

直接创建一个base.json文件并粘贴代码肯定是错误的，我按照我对 Tauri 配置的诸多理解进行了修改，也依然报错

最简单的方式是直接在default.json中复制代码块

{
  "$schema": "../gen/schemas/desktop-schema.json",
  "identifier": "default",
  "description": "Capability for the main window",
  "windows": ["main"],
  "permissions": [
    "core:default",
    "opener:default",
    {
      "identifier": "http:default",
      "allow": [
        {
          "url": "https://*.*"
        },
        {
          "url": "http://*.*"
        }
      ]
    }
  ]
}

然后就可以正常使用了

使用 SQL 插件

构建配置

这个插件官方的文档也有点小问题

首先，在Cargo.toml文件中添加以下内容

[dependencies.tauri-plugin-sql]
features = ["sqlite"] # or "postgres", or "mysql"
git = "https://github.com/tauri-apps/plugins-workspace"
branch = "v2"

然后使用以下命令下载插件

1	npm add https://github.com/tauri-apps/tauri-plugin-sql#v2

我们在 Tauri 中注册插件

// src-tauri/src/main.rs
fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_sql::Builder::default().build()) // 注册插件
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

官网的说明就到这里，实际上，你还需要在src-tauri\src\lib.rs中添加如下代码

#[tauri::command]
fn greet(name: &str) -> String {
    format!("Hello, {}! You've been greeted from Rust!", name)
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_http::init())
        .plugin(tauri_plugin_opener::init())
        .plugin(tauri_plugin_sql::Builder::default().build()) // 添加
        .invoke_handler(tauri::generate_handler![greet])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

类型转换

不知道为什么，我们通过execute执行 sql 语句，拿回来的 Date 类型和 Boolean 类型都变成了字符串类型，而且 TypeScript 并看不出来变量的实际类型，导致类型转换的时候还要套一层unkown

1	const completed = JSON.parse(rawPlan.completed as unknown as string);

使用自定义动态库

先 🕊 着

devzat 使用指北

2025-04-13T03:43:47.000Z

项目地址：quackduck/devzat: The devs are over here at devzat, chat over SSH!

我进行了简单的汉化：markzhang12345/devzat: The devs are over here at devzat, chat over SSH!

聊天室太冷清了，快进来玩

devzat 简介

devzat 是程序员专属的 SSH 聊天室。这是一个通过 SSH 连接的聊天室，用户无需安装客户端，仅需一条 SSH 命令即可登录。它支持私人消息、多聊天室、图片和代码高亮等功能，还可以集成第三方服务、自托管 SSH 聊天室。

快速启动

环境要求

首先，确保你的电脑有 SSH 客户端。正常用过 git 的电脑中都应该有 SSH 客户端了，没有的可以去下载 OpenSSH

然后，确保你的电脑中存在 SSH 密钥对，虽然我并未设置对密钥进行认证，但是你得有一个

可以使用以下命令创建 SSH 密钥对：

ssh-keygen -t rsa -C "youremail@example.com"
ssh-keygen -t ed25519 -C "your_email@example.com"

基本上对密钥版本没有特殊的要求，选一个创建就行，输完命令之后一路回车即可

快速启动

打开任意终端，输入命令

1	ssh <用户名>@60.205.131.158 -p 11451

即可连接至聊天室

有时候维护服务区重启项目，可能需要使用以下命令删去原先的指纹

1	ssh-keygen -R "[60.205.131.158]:11451"

用户名就是你的网名，随便起就行

不快速的启动

每次输入一长串命令太麻烦？可以直接在用户文件夹下的.ssh/config中添加以下配置

Host devchat          # 自定义别名（可随意命名）
    HostName 60.205.131.158
    Port 11451
    User <用户名>       # 你的用户名

现在只需输入 ssh devchat 即可自动连接

WebSocket 原理与 Go 语言实现

2025-03-17T03:43:47.000Z

隔了半个月才发出来，咕咕咕

WebSocket 这玩意用的不少了，从 JavaScript 到 Go，用过各种各样的包来实现这玩意的服务器或客户端。然而，直到现在我对这玩意的原理还是模模糊糊的，趁这个机会，好好学一下 WebSocket 的原理

从 HTTP 到 Websocket

二者关系

虽然 WebSocket 区别于 HTTP，是全双工通信协议。但其并非完全独立于 HTTP，而是基于 HTTP 的升级机制

其核心原理，是通过一次 HTTP 的握手，建立持久连接，然后转变为双向二进制帧传输

升级过程

握手请求

首先，客户端应该先发送 HTTP 握手请求

GET /ws HTTP/1.1
Host: example.com
Connection: Upgrade
Upgrade: websocket
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==  # 随机 Base64 字符串
Sec-WebSocket-Version: 13

其中，Connection: Upgrade和Upgrade: websocket字段，明确要求协议升级

Sec-WebSocekt-Key用于服务端生成生成响应密钥，防止中间代理缓存 WebSocket 帧

最后那个字段用于指定协议版本

响应

成功响应的响应头如下所示

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=  # 基于客户端密钥生成

这里唯一值得注意的操作，就是这里的密钥生成规则

服务端将客户端发送的Sec-WebSocket-Key字段内容，拼接在字符串常量后，计算 SHA-1 后，转为 Base64 编码，作为Sec-WebSocket-Accept字段的内容返回

在 Go 语言中，girilla/websocket库自动完成此计算，我们并不需要手动处理这块内容

TCP 连接复用

握手完成后，Websocket 接管刚刚完成的 TCP 连接，后续的数据将以 WebSocket 帧格式传输

Go 语言中，存在net/http包将原始 TCP 连接抽象为http.ResponseWriter和http.Request，我们用这两个对象向 Websocket 中读写消息

同时，在girilla/websocket库中存在Upgrader.Upgrade()方法，从http.ResponseWriter中提取底层的 TCP 连接net.Conn，并切换为 WebSocket 协议处理器

Go 语言实例

以下提供一个简单的 Go 实现的 WebSocket 服务器：

package main

import (
"log"
"net/http"
"github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
return true
},
}

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Println("WebSocket 升级失败:", err)
return
}
defer conn.Close()

log.Println("客户端已连接:", conn.RemoteAddr())

for {
messageType, message, err := conn.ReadMessage()
if err != nil {
log.Println("读取消息失败:", err)
break
}

log.Printf("收到消息: %s", message)

if err := conn.WriteMessage(messageType, message); err != nil {
log.Println("发送消息失败:", err)
break
}
}

log.Println("客户端已断开:", conn.RemoteAddr())
}

func main() {
http.HandleFunc("/ws", handleWebSocket)

log.Println("WebSocket 服务器已启动，监听端口 8080...")
if err := http.ListenAndServe(":8080", nil); err != nil {
log.Fatal("服务器启动失败:", err)
}
}

来看代码

依赖

import (
"log"
"net/http"
"github.com/gorilla/websocket"
)

log：用于记录日志(虽然但是，Go 的日志系统还是依托)
net/http：提供 HTTP 服务器功能
github.com/gorilla/websocket：提供 WebSocket 协议的实现

实例化 WebSocket 升级器

var upgrader = websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
return true
},
}

将升级的关键函数Upgrader通过upgrader实例化，并重写了CheckOrigin字段中的函数

这玩意是用来控制跨域请求的，默认只允许同源请求，即 WebSocket 请求的 Origin 头与服务器主机完全匹配时，连接才会被允许，即

相同的协议(http/https)
相同的主机名
相同的端口号

所以，不管时调试还是生产环境，一般都是要重写的

处理 WebSocket 连接

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Println("WebSocket 升级失败:", err)
return
}
defer conn.Close()
...
}

我们用实例化的upgrader.Upgrade，拿到 HTTP 中的 TCP 读写，然后交给 WebSocket 控制，使其升级为 WebSocket 连接conn

吐槽一下 Go 的 err 机制，太繁琐了

记得使用defer conn.Close确保函数结束时连接关闭，释放资源

消息处理循环

for {
messageType, message, err := conn.ReadMessage()
if err != nil {
log.Println("读取消息失败:", err)
break
}
log.Printf("收到消息: %s", message)
if err := conn.WriteMessage(messageType, message); err != nil {
log.Println("发送消息失败:", err)
break
}
}

使用conn的ReadMessage方法，从 WebSocket 客户端中读取消息，返回消息类型和内容

这里的WriteMessage方法可以将消息写入 WebSocket 客户端，这里为了演示，直接将接收到的消息原样返回了

启动 HTTP 服务器

func main() {
http.HandleFunc("/ws", handleWebSocket)
log.Println("WebSocket 服务器已启动，监听端口 8080...")
if err := http.ListenAndServe(":8080", nil); err != nil {
log.Fatal("服务器启动失败:", err)
}
}

这里使用http.HandleFunc方法，将/ws路径的请求交给handleWebSocket处理，并使用http.ListenAndServe方法，将服务启动在本机 8080 端口

尝试复现一个 vv 表情机器人 —— 基于 LagrangeGo 的实现

2025-03-13T03:43:47.000Z

markzhang12345/vvBot: 一个基于 LagrangeGo-Template 和 vv433 的自动 vv 表情包 qq 机器人

之前看到一个有关 vv 的开源项目，感觉特别有意思

Cicada000/VV: 你还在为自己存放的 VV 表情包不够多，使用时觉得不够贴切而感到烦恼吗？快来试试这个项目吧！

当时觉得实现一个能够自动发送 vv 表情包的机器人特别有意思，但是手头事情很多，就暂时搁置了

虽然当天就看到某个学长已经实现了类似的机器人，但还是想着自己能不能复现一次

于是这几天，忙里偷闲整出来一个

框架选择

koishi

开始了解有关机器人的框架，发现好像 koishi 很火，而且需要的环境正好全部都有，甚至还有管理面板，于是打算使用 koishi

然而，开始阅读文档之后，发现实现自己的自定义插件好像不如我想的那么简单，而且，最重要的是，我需要的第三方 Bot 插件已经不能用了

于是决定转战其他框架

LagrangeGo

在使用搜索引擎简单检索之后，决定尝试使用 LagrangeGo 这款协议

这玩意是本质上是 Lagrange.Core 的 Go 语言实现，其中 Lagrange.Core 的官方文档中存在的实现方式有如下几种：

C#
Python
Golang

你说的对，但是我不会 C#，不如说最近看某个项目的 C# 代码看的我及其头大。Python 又总是给我一种效率低的错觉，可以的话还是想用编译型语言

所以最后选择用还算熟悉的 Golang 进行编写

LagrangeGo 的仓库中，说明这个协议实现不推荐直接使用，可以用基于此项目的 go-cqhttp 或者模板框架 ExquisiteCore/LagrangeGo-Template 实现

我一看，欸，go-cqhttp 也被大手 👊🐔 了，而且我想实现的 bot 暂时也不需要集成那么多功能，于是选择了使用 LagrangeGo-Template

功能实现

想要在模板的基础上添加功能，我们需要简单了解这个模板的构成

让我来看一看源码，嗯…

好，让我们来编写这个 bot 的功能

调用 API ?

注意到，文章开头提到的 Cicada000/VV 提供了一个具有模糊搜索功能的 API 调用，我一开始的想法是直接调用这个 API，然后获取对应的表情包

折腾了一下，发现这玩意的响应竟然是一组 json 而不是一个，让我调试了半天

然后解析他给我的 json，发现只给出来对应表情视频帧的位置

没找到视频在哪里，所以开始想其他办法

使用 vv433

某位好友在这个时候向我提供的他的武器库，vv433 —— 带有标题的 433 张 vv 表情包，于是决定直接调用武器库

简单整理 vv433，只保留 png 格式文件，改装成 vv428

考虑到功能对于文件访问的高频性，这里简单将武器库的文件名整理成 json 文件，以便直接放进 go 程序的内存，实现快速查询

写个 Python 脚本

import os
import json

source_dir = 'vvSource'
output_file = 'filenames.json'

png_files = []
for filename in os.listdir(source_dir):
    file_path = os.path.join(source_dir, filename)
    if os.path.isfile(file_path) and filename.lower().endswith('.png'):
        png_files.append(filename)

png_files.sort()

with open(output_file, 'w', encoding='utf-8') as f:
    json.dump(png_files, f, indent=4, ensure_ascii=False)

print(f"已生成 {output_file}，包含 {len(png_files)} 个PNG文件。")

搜索逻辑

实在没时间写模糊语义处理，而且也不会写，于是直接暴力查询

先全字匹配，再部分匹配，匹配不到就随机，匹配到多个也随机

只能说 vv 还是太全面了，随机出来的表情包意外的有节目效果

这里不再贴出源码了，想看的直接去仓库看就行

修改于 2025-4-6

其实几周后就做了个简单的模糊语义处理，但是太懒了所以现在才发

也没有什么，因为我自己实在不会写，Go 有没有现成的好用的库，所以干脆直接把选择逻辑全扔给 AI 做了，顺便写了几个好玩的（神必的）AI 交互

待实现

模糊语义搜索（升级版）
绕开 QQ 的机器人检测

你说的对，但是我头一天只是调试了一下 bot，第二天号就被封了

姑且是加了点随机时延，然后增加了手动发送文字功能，但还是觉得不保险

正在想怎么模拟正常用户的行为

使用 VirtualBox 虚拟机安装 openEuler

2025-03-09T03:43:47.000Z

下载 VirtualBox

首先，从官网下载 openEuler 安装程序

最新版本是 7.1.6，然而，在 7.0.14 到 7.0.16 的版本更新中，VirtualBox 将安装路径默认固定在了系统盘中，以防止用户重新写入或者重命名文件夹。但是我的 C 盘容量告急，所以这里选择查找历史版本 7.0.12 来进行安装

下载 openEuler 镜像

进入openEuler 下载，选择合适的稳定版本

这里我暂时不在此环境中进行开发，所以选择进行最小安装

耐心等待下载即可

创建 openEuler 虚拟机

新建虚拟机

进入 VirtualBox，点击新建，开始创建虚拟机

为啥显示检测到了 Red Hat 呢，收集资料显示，openEuler 早期计数路线沿用了红帽系得 RPM 软件包管理系统和文件系统布局，和 CentOS 极为类似。这样，该系统能够兼容大量 CentOS/RHEL 开发的应用

不过我这里选择了跳过自动安装，这个自动检测类型应该不会有太大影响

分配 2GB 内存，给 2 个 CPU 核心，给 10GB 的虚拟硬盘

导入系统镜像

双击启动虚拟机，按照提示导入系统镜像

出现如下页面，启动成功

按照引导进行系统设置，预设好 root 账户和用户，就可以开始安装系统了，耐心等待即可

使用鼠标在虚拟机中进行操作时，虚拟机会自动捕获鼠标，使用右侧的 CTRL 键即可解放鼠标

安装好后，重启系统即可开始使用

注意，这里按照默认提示，仍然会进入虚拟盘的安装流程，这里应该先弹出安装系统使用的镜像，再重启系统

使用预设的用户名和密码登录，即可进入命令行界面

输入pwd查看当前路径

输入ping www.bilibili.com，显示如下响应

网络功能正常，此虚拟机运行成功

使用 SSH 连接虚拟机

在虚拟机的命令窗口中，鼠标会被捕获，没有语法高亮，且不能复制粘贴一些常用命令，所以我尝试在宿主机中使用 SSH 来连接本地的虚拟机

虚拟机默认的网络环境是 NAT 环境，即 VirtualBox 内置的 NAT 引擎充当虚拟路由器，分配一个私有 IP，将所有流量转发至主机的网络接口，进行地址转换后再访问外网

我们可以使用ip addr命令找到这个私有 IP：

但是，使用 NAT 模式是无法被宿主机访问的，所以我们尝试使用桥接模式

桥接

桥接，是通过将虚拟机直接连接到主机物理端口，把虚拟机当成局域网中的独立设备

通过手动取得宿主机静态 IP，我们可以通过给虚拟机的网卡分配同一网段下的 IP 地址，从而通过宿主机 SSH 访问

在网卡设置/etc/sysconfig/network-scripts/ifcfg-enp0s3中，我进行了如下修改

# ifcfg-enp0s3（静态IP）
BOOTPROTO=static
IPADDR=192.168.1.100
NETMASK=255.255.255.0
GATEWAY=192.168.1.1

然而，可能是我的无线网卡(AX 210)不支持桥接需要的混杂模式，或是我的配置过程出了问题，桥接之后，即使分配了 IP，虚拟机也一直无法连接外网

考虑使用 NAT + Host-Only 双网卡实现 SSH 连接

NAT + Host-Only

仍保持默认的 NAT 网卡不变，我们在虚拟机设置中添加一块新的虚拟网卡

其中，这个 Host-Only 工具是在你下载 VirtualBox 的过程中自动下载的

然后，我们需要手动为自己的新网卡编写设置。首先使用ip addr找到新网卡的名称，我这里是enp0s8

然后，在/etc/sysconfig/network-scripts/目录下编写ifcfg-enp0s8文件，我的内容如下

DEVICE=enp0s8
NAME=enp0s8
TYPE=Ethernet
IPADDR=192.168.56.101
NETMASK=255.255.255.0
GATEWAY=192.168.56.1
DNS1=8.8.8.8
DNS2=8.8.4.4
ONBOOT=yes

这样，我就可以在宿主机的命令行中通过 ssh 192.168.56.101连接至虚拟机了

疑问

我因为使用 Docker 的原因，开启了 WSL2 服务，电脑的 hyperV 应该是正常开启的。然而，在虚拟机安装过程中，并没有像其他人一样遇到启动报错的问题

VirtualBox 从 6.0 版本开始支持与 Hyper-V 共存，但是我并没有使用过这项配置

网络上关于这两个兼容性的文章都比较久远，可能是某次稳定版本更新之后默认开启的兼容设置吧

然后，为什么我的桥接设置始终失败，这很奇怪

考虑我的宿主机静态 IP 设置有误，或者真的是这块无线网卡不支持 VirtualBox 的混杂模式

写一个模拟 GPS 定位程序

2025-03-07T07:43:47.000Z

markzhang12345/MockLocation: 一个安卓 GPS 信号模拟工具

不想 Keep 打卡，所以尝试找出一个比较好的替代方案。原本的想法是写一个基于 adb 命令的简单脚本，然后对手机发送定位命令，如

adb shell geo fix 116.397428 39.908717

adb shell am startservice -a com.android.location.service.v3.NetworkLocationProvider --es network-location "{'latitude':39.908717,'longitude':116.397428,'accuracy':10.0}"

然而，第一种方式在Android 14中已经不再适用，第二种方式需要手机的 root 权限。手边并没有的设备给我折腾 root，所以考虑写一个安卓软件

为什么要写安卓

你说的对，但是现在的安卓版本虽然禁用了adb shell geo fix方法，在开发者选项中仍然存在模拟位置信息应用，所以我们直接在应用中调用ACCESS_MOCK_LOCATION权限，就可以为手机提供位置模拟服务

电脑上还留着大一时候下载的 Android Studio，倒是也不用新增环境，直接新建项目开始琢磨

这里想着直接用 Kotlin 一步到位，但是越写越发现自己根本没写过完整的面向对象的项目。之前写 C++ 的原因也只是 STL 好用，完全没有认真尝试过他的面向对象特性。连带着这两天看 C# 也非常头大
开始认真思考要不要看着 Java 好好学一下面向对象的写法

项目新建后会出现一堆乱七八糟的文件结构，在刚开始开发的时候确实让人无从下手。简单分析之后，其实需要关注的文件只有以下三个：

MainActivity.kt，入口文件
activity_main.xml，页面配置，类似前端的 HTML
AndroidManifest.xml，配置文件

AndroidManifest.xml

既然我们软件的核心功能是通过ACCESS_MOCK_LOCATION实现的，那么当然首先应该在配置文件中声明该权限

1
2
3

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_MOCK_LOCATION" />

ACCESS_FINE_LOCATION允许应用获取精确位置信息，这里就是使用 GPS 获取高精位置
ACCESS_COARSE_LOCATION允许应用获取大致位置信息，例如基于网络的位置
ACCESS_MOCK_LOCATION允许应用创建模拟位置并将其提供给系统

其实理论上来讲，以上三个权限都是非必要的。我的软件只需要提供位置信息，并不用获取位置信息。而第三个权限在Android 6.0版本纸上已经被开发者模式的设置取代了……

写文章的时候意识到ACCESS_MOCK_LOCATION这个影响我软件打包的权限竟然是非必要的，删了之后果然能够正常打包了，并且不影响软件的正常运行
被自己气笑了
权限需要使用adb shell appops set icu.kpmark.mocklocation android:mock_location allow手动赋予，开发者选项中可能没有

activity_main.xml

然后就是简单设计软件页面，因为这个软件的功能实在是比较单一，暂时也没有什么扩展的接口，于是设置一个开始/结束键用来绑定stop()和start()函数就好了

没了

以后考虑添加路径，速度选择功能，但是经纬度计算实在是有点难处理，所以暂时搁置

MainActivity.kt

这个是程序的入口文件，我们在这个文件中重写系统父类AppCompatActivity中的onCreate方法，启动视图模式，并使用根视图处理窗口插图

其实最主要的，处理初始化一堆必要的选项之外，只有将我主要逻辑的stop()和start()函数绑定到界面按钮的监听事件上，然后将软件终止事件也绑定至stop()，确保主要逻辑的正确进入与退出

当然不会把主要逻辑写在里面，不然真就编程依托莫名其妙的代码了，这里我们新建MockLocation.kt来存放我们的EnhancedMockLocation类（为什么当时脑子一抽起了这个名字呢）

MockLocation.kt

为了骗过软件，我们必须将模拟信号提供者的名字替换为系统已有的 GPS 提供者，这里我们给出一个提供者数组

// 所有可能的位置提供者
private val providers = arrayOf(
LocationManager.GPS_PROVIDER,
LocationManager.NETWORK_PROVIDER,
LocationManager.PASSIVE_PROVIDER
)

分别是 GPS 传感器，网络定位以及被动身份，毕竟不是所有软件都像高德地图一样，对 GPS 信号毫不怀疑（笑），所以这些假身份越多越好

由于要进行应用的后台运行，这里需要开个协程来运行模拟位置逻辑，然后按照类中预设的经纬度点，力求还原的提供位置信息

这里我们使用interpolationPosition函数来实现两个经纬度点之间的平滑过渡，类似以下逻辑

进度条 += (速度 × 时间差) / 两点距离
if (进度条 > 1.0) {
    切到下个点
    进度条 = 0.0
}

当手机移动速度超过光速时，可以直接触发瞬移特效（误

你说的对，但是我们还要计算方位角来模拟更加真是的方向朝向，这里我们使用以下代码

1 2	val R = 6371000.0 // 地球半径 val a = sin(Δ纬度/2)^2 + cos(纬度1)cos(纬度2)sin(Δ经度/2)^2

尝试计算当前的方位角，但是显然，效果不是很好

这里，我们做了三个比较特殊的算法来尝试骗过软件的自动识别

warmupLocationServices()会先发送三个抖动坐标，用来迷惑手机系统，效果类似：先让系统相信我在北京 → 上海 → 广州之间反复横跳，之后突然出现在纽约就不会被怀疑了
方向角的计算，我使用 5 个历史位置来计算平均方向
尝试速度和方向添加随机噪声，试图模拟手机在身上的随机扰动

val smoothedBearing = calculateSmoothedBearing()
val smoothedSpeed = if (currentSpeed > 0.1) currentSpeed else 0.0

val randomizedSpeed = smoothedSpeed * (0.95 + 0.1 * Random.nextDouble()) // ±5%波动
val randomizedBearing = (smoothedBearing + Random.nextDouble() * 3 - 1.5).toFloat()

for (provider in providers) {
    setEnhancedMockLocation(
        locationManager,
        provider,
        location.latitude,
        location.longitude,
        randomizedSpeed,    // 随机速度
        randomizedBearing   // 假装手抖的方向
    )
}

你说的对，但是在一些运动软件中，这个随机扰动的检测是通过陀螺仪和水平仪之类的其他传感器来检测的，使用 GPS 模拟的效果，只能说聊胜于无

本程序仅供学习交流使用，请勿用作不良用途
目前此软件仅经过不完全测试，请确保安装软件的设备上不存在任何重要信息
错误使用本工具可能导致账号封禁等风险，使用者需自行承担一切后果

聊聊 Git 与 README

2025-02-19T03:43:47.000Z

本人对此的认知有限，故本文只会聊一些最基本的规范

Git

Git是一款免费且开源的分布式版本控制系统，旨在以高速和高效的方式处理从小型到超大型的各类项目。除去基本的版本管理，还可以借助 ssh等协议做到方便、安全的文件传输及代码共享

这里会简单介绍一些我认为比较重要的Git使用规范

Commit

是的，使用Git最重要的一件事就是进行版本控制，而git commit -m "<信息>"命令就是提交当前更改的重要方式、

而 Commit 中信息的编写规范非常重要，可以非常直观的提供此次更改内容的变化情况，尤其是在与合作者协同开发的情况下，可以帮助他人一眼看出你的改动内容，是代码写完之后非常重要的一项流程

[!WARNING]
存在不包含相关信息的 commit 命令，这里为了诸位的身心健康，不做介绍

有的同学可能会说了，我写完代码很累了，还要写 commit 不是折磨人吗？

想象一下，当您早上打开仓库开始工作，看的同事 commit 长成下面这样，您的血压会不会飙升

fix
修改 bug
设计页面
2.12
添加用户个性化设置功能, 实现用户主题与图片定制功能, 添加四个新API端点, 实现文件管理和Token验证......(此处省略一万字)

心脏强大的同学，或者说完全不关心别人干了什么的同学可能觉得这样无伤大雅，但是为了世界和平，我必须在这里介绍一下规范的 commit 写法，并推荐大家按照规范合理的编写自己的 commit

当然有些同学可能在一些大的开源项目中看到如下提交

注意这里的提交是回应相关 issue 的，详细信息应转至对应页面查看

Angular 规范

目前最受开发人员肯定的规范是前端框架Angular提出的Angular 提交信息规范

这里给出提交格式

<type>():

每次提交必须包括页眉(header)内容，其余正文body和页脚footer视改动情况定

每次提交不超过100个字符

这里简单介绍一些type字段类型

build：对构建系统或者外部依赖项进行了修改
docs：对文档进行了修改
feat：增加新的特征
fix：修复bug
refactor：既不是修复bug也不是添加特征的代码重构

更多详细信息可以参看连接给出的官方文档
这里搬运一些规范的Angular提交信息

feat(UserProfile): add user profile editing feature

This commit introduces a new feature that allows users to edit their profiles
directly from the user interface. The motivation behind this change is to
enhance user interaction and provide a more seamless experience.

Previously, users had to navigate to a separate editing page to update their
profile information. With this new feature, users can now make changes
efficiently from their profile page, eliminating unnecessary steps in the
workflow.

Changes included in this commit:
- Added a new 'Edit Profile' button on the user profile page.
- Implemented frontend components for profile editing.
- Updated backend API to handle profile updates securely.

By streamlining the profile editing process, we aim to improve overall user
satisfaction and make our application more user-friendly. This enhancement is
in response to user feedback, addressing the need for a more intuitive and
accessible way to modify profile details.

Closes #234

fix(Validation): correct input validation logic

This commit addresses an issue related to input validation logic in the
application. Previously, the validation process was not handling certain edge
cases correctly, leading to unexpected behavior in specific scenarios.

To resolve this issue, the validation logic has been revised to properly
handle various input scenarios. This ensures that user input is thoroughly
validated, reducing the likelihood of errors in the application.

The changes made in this commit include:
- Correcting boundary checks for user input.
- Improving error messages for better user guidance.

These adjustments align with our commitment to delivering a robust and
reliable application experience.

Closes #123

个人理解

有的同学可能会说了，小体量项目没必要写的这么规范吧，随便写写不就行了？

[!WARNING]
以下内容仅代表我个人观点，若有不同意见，欢迎联系作者进行友好交流

如果同事或者队友明确表示不在意的话，请自便

其余情况，我个人建议您的提交起码包括以下内容

git commit -m "一句话交代大致工作

- 详细条目1
- 详细条目2
 - 子条目21"

其中，若提交能够被简短的一句话描述，可省略详细后续内容(务必确保您的工作能被简短的一句话完全概括)

其中，若改动内容较多，建议可以稍微详细的对后续条目进行编写(务必确保您的工作不能被简短的一句话完全概括)

这里给出作者的 commit 以供参考

修复查询帖子 bug 逻辑，新增用户历史发布 API

- 修复查询帖子(GET /search)空列表问题
 - 修复空列表重复响应200状态码
 - 新增响应 count 字段表示当前页数量

- 新增用户历史发布接口(GET /user-history)
  - 支持分页查询
  - 包含帖子总数、当前页数量统计
  - 返回帖子详情及关联图片

- 增改相关 API 文档

可视化查看工具

Git的基本操作是命令行命令，虽然对于基本的提交，拉取，推送之类的命令支持良好，但是当你需要查看具体改动的时候，命令行操作实在是相当不方便

这里提供几个不需要特意下载的可视化工具

Github

Github作为世界上最大的开源代码托管平台，其名称中的Git已然彰显了其与Git的密切关系

这里以Tencent/puerts: PUER(普洱) Typescript. Let’s write your game in UE or Unity with TypeScript.仓库为例稍作演示

在仓库的代码主页，你能很轻松的看到 commit 标识

点击左上角 Commit，进入提交详情

这里已经能很详细的看到提交结果了，我们再点进详情页

这里的红绿色块非常明显的提示了相应的增改内容

Vs code

你说的对，但是 vs code 内置了一款Git可视化工具，可以辅助进行更改的提交，推送

还有好用的冲突管理器，让你不用再Git默认的Vim编辑器中进行冲突的更改

这里给出官方使用文档Visual Studio Code 中的 Git 简介

README

一个好的项目，必然有一份好的README，无论这份README是面向开发者还是使用者，都应该进行认真地进行撰写

一份好的README是项目标配，然而其作用并非彰显该项目的专业性或满足自己的展示欲，您的README应该以解决开发者或使用者可能存在的疑惑为目的

古早的游戏文件中，常常能看见txt格式的README文件，直到现在有些游戏仍然使用html网页文件来进行项目描述

然而在如今的开源项目中，通常使用markdown语法来撰写README.md文件，GitHub 要求开源项目必须包含 README.md，否则会显示警告提示

那么，一份完整的项目README应该说明哪些内容呢？

软件定位及基本功能
运行代码的方法：环境、启动命令…
简要使用说明
代码目录结构说明
常见问题说明

作为一份完整的README，其还包括一些在代码早期开发中不需要填写的内容

版权和许可信息
作者列表
社区介绍
联系信息
法律声明

近期拾遗-关于建站

2025-02-17T03:43:47.000Z

关于 Frp 的安全问题

曾今心心念念想要有低成本的实体服务器，在了解树莓派之后觉得终于有一个可行的解决方案了，遂自购树莓派 4b 开始折腾

某位同学曾使用过 Sakura Frp 内网穿透进行过游戏联机，于是打算用这个方案进行内网穿透

本来以为将局域网内设备暴露至公网不会出什么大事，直到在研究校园网/公司内网穿透方案时看到了如下两个帖子

道心破碎，开始重视 Frp 的安全问题

安全隐患

简单来讲，通过内网 Frp 客户端和外网 Frp 服务端之间的连接，可将内网打通，攻击者通过访问 frp 服务端主机的指定端口，可实现对内网路由可达的任意主机的访问

从影响上来讲，最坏的情况并不是进行穿透的主机被控制，毕竟个体身份的信息体量一般不会特意招致黑客攻击（笑），但是对局域网内其他设备的威胁确实是不容忽视的

尤其是在公司内网和校园网环境下，同局域网内的服务主机中存有重要信息的情况下，招致攻击的风险和后果严重程度都将大大提升

以校园网环境举例，一般网信中心都会对这类穿透服务进行拦截，然而，大多数 Frp 客户端，都有如下功能

当然，在这里只放这一张图片是不负责任的，我们将原版网页的截图放出

那么，为什么 Frp 方案有如此多的安全隐患，还能成为相当主流的一种公网方案呢？

除开低成本和众所周知的一些因素，其实是有对应措施缓解安全问题的，由于本人了解并不过深，这里仅列举几种

Frp 安全方案

仅开放必要端口

以 Web 网页为例，尽量只开放默认 80端口，该端口一般由 Nginx 之类的反向代理工具提供服务，可以较为安全的进行代理转发，**较难(?)**被渗入

同时，千万不要轻易将 22/3389 端口暴露，默认 ssh 连接的 22 端口一旦被攻入，很容易取得主机的 root 权限，远程桌面的 3389 端口同理

若因实际需求不得不暴露这两个端口，请务必限制访问 ip 并设置复杂度高的相关密钥

强制使用 TLS 加密通信

你说的对，但是 TLS 不仅能绕过监管，其本身也是一种加密通信协议，这种服务能相当有效的阻挡中间人攻击

默认情况下的 Frp TCP 流量是明文传输的，攻击者可窃听或篡改传输数据(http 请求、数据库连接)，使用强制 HTTPS 和 TLS 服务能有效的对流量进行加密

使用高位端口

常见端口如 3000、5000、8080 等端口尽量避免开放，这些端口比较容易被工具扫描，引发暴力破解或漏洞引用

隔离环境

主播主播，你的环境确实很危险，但是我就在家庭环境下开个 NAS，有没有什么强势又简单的安全措施

有的兄弟，有的

使用 DMZ 服务，可以在家庭网络下创建一个单独的区域，这个区域内的设备映射到网络中，即使被攻击或入侵，也不会影响到区域外的其他设备

具体操作涉及路由器操作，可以参照以下 up 的视频进行配置

家庭网络下，玩内网穿透的服务器，是不是应该隔离防护一下

忠告

保险起见，无论诸位大神的网安技能多优秀，我不建议任何人在校园网/公司内网环境下使用 Frp 进行内网穿透

实在想进行远程控制的同学们，可以研究更加安全的 VPN 方案

Linux 云端操作感想

在折腾云服务器的时候，大致流程和树莓派差不多，少了 Frp 的一些奇怪问题后，Nginx 的配置简单了很多

但是，由于云服务器中定制 Ubuntu 系统相当安全(雾)的用户权限管理，网站搭建中 90% 的原因都来自于文件权限不足，剩下 10% 来自于用户服务的混乱

建议同学们在使用 root 进行操作和其他用户进行操作时遵循一定的规则逻辑，尽可能减少因为用户权限不同造成的各种奇怪 bug

apt 作为包管理器确实相当方便，定制系统已经预先将镜像源换成了阿里云，在下载各种环境的时候并不需要像在 win 上一样折磨

考虑到代理问题，使用 apt 部署简单网页环境的时候确实比 Docker 部署还好用，毕竟一 pull 半小时、一看已失败的效果非常容易让人红温

云服务的安全组规则和免费的 ddos 防护确实让人无比安心，愿意的话花点小钱(并非小)还能享受企业级的安全防护，不过 2G2 核的便宜服务器确实没什么黑入的价值就是了

vsc 的远程接入后 2G 的内存几乎能被吃满，我也不知道为什么 vsc-server 这么吃内存，感觉不如学着用一下 Vim，直接 powershell 进行 ssh 连接了

写一个树莓派状态检测服务

2025-02-15T03:43:47.000Z

好想给自己的网页加点功能

环境准备

考虑到树莓派对 python 的支持良好，且 python 的各种包实在是非常好用，这里用 python 的 Flask 框架作为网页后端

树莓派 raspberryPi OS 中的 python 环境作为系统服务，是不允许直接使用 pip 进行包管理的，这里我们使用 Debian 维护的，非常好用的 apt 包管理器来安装需要的 python 包

有良好习惯的同学们可能有疑问，为什么不使用 python 进行虚拟环境的隔离呢？因为虚拟环境中无法直接调用树莓派有关系统环境的 API，需要使用python -m venv --system-site-packages <虚拟环境路径>参数在虚拟环境中调用全局系统包，那我为什么不直接用全局环境呢？我暂时没有发现比较好的办法

我们使用以下命令下载需要的包

# 更新系统包列表
sudo apt update

# 安装所需的 Python 包
sudo apt install python3-flask python3-psutil python3-flask-cors

这里，pyhton3-flask和python-flask-cors分别是 Flask 框架和对应的跨域服务，python3-psutil则是调用系统状态的 API 所必要的包

服务器实现

在你喜欢的地方，写一个后端提供系统数据的 API，这里我在 /home/kpmark/nav/status.py中进行编写

import psutil
from flask import Flask, jsonify
from flask_cors import CORS

app = Flask(name)
# 允许特定域名的跨域请求
CORS(app, resources={
    r"/status": {
        "origins": ["https://www-blog.u2330056.nyat.app:49191"],
        "methods": ["GET"],
        "allow_headers": ["Content-Type"]
    }
})

@app.route('/status')
def get_status():
    cpu_percent = psutil.cpu_percent(interval=1)
    memory = psutil.virtual_memory()
    disk = psutil.disk_usage('/')
    temperatures = psutil.sensors_temperatures()

    # 获取CPU温度（针对树莓派）
    cpu_temp = None
    if 'cpu_thermal' in temperatures:
        cpu_temp = temperatures['cpu_thermal'][0].current

    return jsonify({
        'cpu_percent': cpu_percent,
        'memory_percent': memory.percent,
        'disk_percent': disk.percent,
        'cpu_temp': cpu_temp,
        'memory_total': memory.total,
        'memory_used': memory.used,
        'disk_total': disk.total,
        'disk_used': disk.used
    })

if name == 'main':
    app.run(host='127.0.0.1', port=3001)

这样，就有一个后端可以挂在你树莓派的 3001 端口了，但是我们想让他自动在后台启动，需要配置相应的系统服务

配置系统服务

这里，使用以下命令创建 systemd 服务文件

1 2	sudo cd /etc/systemd/system/ sudo touch raspstatus.service

然后填入以下内容

[Unit]
Description=Raspberry Pi Status API
After=network.target

[Service]
User=kpmark
WorkingDirectory=/home/kpmark/nav
ExecStart=/usr/bin/python3 /home/kpmark/nav/status.py
Restart=always

[Install]
WantedBy=multi-user.target

Description：描述服务的名称和用途，这里是 “Raspberry Pi Status API”
After：指定服务启动的依赖顺序，表示该服务将在 network.target（网络服务）启动后才启动，确保网络可用
User：指定运行该服务的用户，这里是 kpmark。服务会以该用户的权限运行
WorkingDirectory：设置服务的工作目录，这里是 /home/kpmark/nav。服务启动时会切换到该目录
ExecStart：指定启动服务的命令，这里是使用 Python 3 执行 /home/kpmark/nav/status.py 脚本
Restart：定义服务在什么情况下重启。always 表示无论服务因何原因退出，都会自动重启，确保服务持续运行
WantedBy：指定服务的启动级别或目标。multi-user.target 是多用户环境的目标，表示该服务会在系统启动时自动启动

然后，我们通过以下命令启动该服务

1
2
3

sudo systemctl daemon-reload
sudo systemctl enable raspstatus
sudo systemctl start raspstatus

出现问题的话，可以通过以下命令调出服务日志进行查看

1 2	# 查看服务日志 sudo journalctl -u raspstatus -f

Nginx 配置

由于涉及到后端的跨域请求，这里需要对 Nginx 进行一些配置

# 状态API代理
location /status {
        proxy_pass http://127.0.0.1:3001/status;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;

        # CORS 配置
        add_header 'Access-Control-Allow-Origin' 'https://www-blog.u2330056.nyat.app:49191';
        add_header 'Access-Control-Allow-Methods' 'GET, OPTIONS';
        add_header 'Access-Control-Allow-Headers' 'DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range';
        add_header 'Access-Control-Expose-Headers' 'Content-Length,Content-Range';

        if ($request_method = 'OPTIONS') {
            add_header 'Access-Control-Allow-Origin' 'https://www-blog.u2330056.nyat.app:49191';
            add_header 'Access-Control-Allow-Methods' 'GET, OPTIONS';
            add_header 'Access-Control-Allow-Headers' 'DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range';
            add_header 'Access-Control-Max-Age' 1728000;
            add_header 'Content-Type' 'text/plain; charset=utf-8';
            add_header 'Content-Length' 0;
            return 204;
        }

这里我们直接将 /status转发至后端，这样就不用在前端写出完整的请求路由了

proxy_pass：将匹配的请求代理到 http://127.0.0.1:3001/status，即转发到本地的 3001 端口上
proxy_set_header：设置代理请求的 Host 头为原始请求的 Host 值，确保后端服务能正确识别请求的域名
proxy_set_header：设置代理请求的 X-Real-IP 头为客户端 IP 地址，方便后端服务获取真实 IP
add_header：设置响应头 Access-Control-Allow-Origin，允许来自 https://www-blog.u2330056.nyat.app:49191 的跨域请求
add_header：设置响应头 Access-Control-Allow-Methods，允许的 HTTP 方法为 GET 和 OPTIONS
add_header：设置响应头 Access-Control-Allow-Headers，允许的请求头包括 DNT、User-Agent 等
add_header：设置响应头 Access-Control-Expose-Headers，允许客户端访问 Content-Length 和 Content-Range 头信息
还有一堆 OPTIONS请求处理，这里不再赘述其含义

前端实现

这里给出我的前端 demo，仅供参考

<div class="card status-card">
  <h2>树莓派系统状态h2>
  <p>实时系统资源监控p>
  <div class="status-grid">
    <div class="status-item">
      <h3>CPU 使用率h3>
      <p id="cpu-percent">--p>
      <div class="status-bar">
        <div class="status-bar-fill" id="cpu-bar" style="width: 0%">div>
      div>
    div>
    <div class="status-item">
      <h3>内存使用率h3>
      <p id="memory-percent">--p>
      <div class="status-bar">
        <div class="status-bar-fill" id="memory-bar" style="width: 0%">div>
      div>
    div>
    <div class="status-item">
      <h3>CPU 温度h3>
      <p id="cpu-temp">--p>
      <div class="status-bar">
        <div class="status-bar-fill" id="temp-bar" style="width: 0%">div>
      div>
    div>
    <div class="status-item">
      <h3>磁盘使用率h3>
      <p id="disk-percent">--p>
      <div class="status-bar">
        <div class="status-bar-fill" id="disk-bar" style="width: 0%">div>
      div>
    div>
  div>
div>

<script>
  function formatPercent(value) {
    return `${value.toFixed(1)}%`;
  }

  function formatTemp(value) {
    return `${value.toFixed(1)}°C`;
  }

  function updateStatus() {
    // 使用当前域名的status路径
    fetch("/status")
      .then((response) => response.json())
      .then((data) => {
        // Update CPU
        document.getElementById("cpu-percent").textContent = formatPercent(data.cpu_percent);
        document.getElementById("cpu-bar").style.width = `${data.cpu_percent}%`;

        // Update Memory
        document.getElementById("memory-percent").textContent = formatPercent(data.memory_percent);
        document.getElementById("memory-bar").style.width = `${data.memory_percent}%`;

        // Update Temperature
        if (data.cpu_temp !== null) {
          document.getElementById("cpu-temp").textContent = formatTemp(data.cpu_temp);
          document.getElementById("temp-bar").style.width = `${(data.cpu_temp / 80) * 100}%`;
        }

        // Update Disk
        document.getElementById("disk-percent").textContent = formatPercent(data.disk_percent);
        document.getElementById("disk-bar").style.width = `${data.disk_percent}%`;
      })
      .catch((error) => console.error("Error fetching status:", error));
  }

  // Update every 2 seconds
  updateStatus();
  setInterval(updateStatus, 2000);
script>

这里我使用原生页面简单的实现了卡片效果如下，也可以使用现代前端框架实现更加美观的界面

如何在 windows 中使用 Docker —— 以 Redis 为例

2025-02-03T03:43:47.000Z

Docker 是一个轻量化的容器技术，它提供了一个独立的环境容器，用于打包和运行应用程序及其依赖。虽然 Docker 容器与虚拟机在功能上有相似之处（如提供隔离的运行环境），但 Docker 容器直接运行在宿主机的操作系统内核上，而不是通过虚拟化硬件来实现，因此更加轻量、快速和高效。Docker 镜像可以在任何支持 Docker 的环境中运行，确保开发、测试和生产环境的一致性

Docker 用于将应用程序及其依赖打包成一个轻量化的容器，实现跨环境的一致性和快速部署
通过 Docker，开发者可以在隔离的环境中运行应用，确保开发、测试和生产环境的无缝迁移。

开启 WSL 环境

很不幸，Docker 原生支持的环境为 linux 和 mac OS，无法直接在 windows 系统中运行，我们需要开启 windows 自带的 linux 子系统

在 win10 环境中，只需要开启 hyperV，即可正常使用 Docker 的客户端(在系统设置中搜索即可)

而在 win11 中，我们需要开启 WSL 服务（WSL2 具有更好的新性能与兼容性，win10 用户在版本允许的情况下也推荐使用 WSL）

首先，打开 windows 设置中以下两项服务

适用于 Linux 的 Windows 子系统
虚拟机平台

然后，重启电脑，以管理员打开 CMD 或者 PowerShell，输入以下命令将 WSL 的默认版本切换至 WSL2

1	wsl --set-default-version 2

然后，输入以下命令下载 WSL

1	wsl --update --web-download

祈祷成功即可

理论上以上操作之后即可正常下载 Docker 客户端，但是你也可以在 WSL 中下载 Ubantu 或者 Arch 这种 linux 发行版当成虚拟机折腾一下

下载 Docker 客户端

推荐直接使用神秘力量进入 Docker 官网下载 docker_desktop_installer_windows_x86_64.exe，当然如果没有什么力量也可以在国内下载到各种镜像下载器

注意通过安装包引导安装是不能指定安装位置的，这里建议在命令行中通过以下命令指定安装路径

1	start /w "" "Docker Desktop Installer.exe" install --installation-dir=D:\Docker

打开 Docker Desktop 的客户端，成功运行即可

输入docker version，得到以下结果即安装成功

这里的客户端提供的云服务与图形化界面，由于十分便于理解这里不做介绍，以下操作仍使用命令行

使用 Docker 运行 Redis 服务

Redis 是一种基于内存的高性能键值存储系统，广泛用作缓存、消息队列和会话存储，以提升应用性能

由于不明原因，其最新版本只能运行于 mac OS 和 linux 上，windows 只存在一个非常古老的版本，这里我们使用 Docker 运行 Redis 服务

在具体项目中要配置的环境不止一种，建议使用 docker-compose 的方式编写配置文件，这里以 MySQL 和 Redis 为例

在配置根目录下新建文件 docker-compose.yml，写入如下内容

version: '3.8'

services:
  mysql:  # MySQL 服务定义
    image: mysql:8.0  # 使用官方 MySQL 8.0 镜像
    environment:
      MYSQL_ROOT_PASSWORD: root   # 设置 root 用户密码
      MYSQL_DATABASE: marketplace # 自动创建数据库
    ports:
      - "3307:3306"  # 将容器内的3306端口映射到宿主机的3307
    healthcheck:  # 健康检查（可选）
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 5s
      timeout: 10s
      retries: 5

  redis:  # Redis 服务定义
    image: redis:alpine  # 使用轻量级 Redis 镜像
    ports:
      - "6379:6379"  # 端口映射
    command: redis-server --save 60 1 --loglevel warning  # 每60秒保存一次

其中两项服务为了便于开发测试，均未设置持久卷

以上文件其实包含了两个容器的配置，一旦启动该 docker 服务，对应得镜像便会依照配置运行在容器内部，我们可以通过其映射的宿主机端口访问服务

在根目录下使用docker-compose up -d运行容器，-d参数使其在后台运行
使用docker-compose down -v删除容器，-v同时删除其临时卷

关于在 Github 上合作开发

2025-01-16T20:43:47.000Z

之前只在自己的 github 仓库中使用 git 工具进行过开发和远程管理，正好这两天有合作开发的需求，学习一下在 github 上进行合作开发的规范

使用 Fork

Fork 公共仓库

进入想要参与开发的公共仓库后，点击右上角 Fork 图标，此时该仓库的一个副本被复制到你的 github 仓库中

这一步不需要原仓库主的同意

然后将该仓库 Clone 到本地，即可对仓库内容进行修改

这是你所有提交的修改都会发生在你的远程仓库中，源代码作者的仓库内容不会发生修改

与原仓库保持同步

有时在你修改代码的过程中原始仓库发生了更新，这里我们需要同步这种更新

当前我们本地仓库的远程仓库应该是 fork 至我们 github 上的仓库

这里我们输入

1	git remote add upstream url

来将本地仓库连接至原仓库

可以使用以下命令确认自己的远程库

1	git remote -v

这里有几个命令来帮助你将远程仓库的内容更新至本地

// 从远程仓库获取最新版本到本地
git fetch upstream master

// 保证当前位于 master 分支
git checkout master

// 将最新版本整合到 master 分支
git merge upstream/master

// 将最新版本发送至自己的 github 仓库中
git push origin master

创建 Pull Request

将修改好的代码提交至自己的代码仓库后，可以在仓库页面点击 New pull request

将修改提交给仓库的管理者

直接使用多人合作仓库

这种可能在共同开发中更常用一点

首先你应该创建公共仓库，然后你可以邀请其他开发这作为合作者

进入仓库
点击 setting
在左侧菜单中选择 Manage access
点击 Invite a collaborator，输入合作者的 Github 用户名或邮箱发出邀请

这样可以实现多人共同管理一个远程仓库，并且每个人的管理权限一致

使用 Typora beta 版

2025-01-15T17:43:47.000Z

markdown 源码敲起来太麻烦？vscode 双窗口看起来太累人？别怕孩子，我带着 Typora 来救你了

为什么用 Typora

即时渲染，随写随读
界面极简，主题丰富
占用小，14M
丰富的快捷键，丰富的自定义功能

我最喜欢图片的是自动生成链接功能，写博客时能省不少力气

使用

付费使用

正式版 89r，可供三台设备使用，找两个人拼一下 30r，也算对得起这个价

当然也有免费使用的方法

免费使用

在几年前的 beta 版中，Typora 是不用收费的，这里我使用的就是最后一代 beta 版 0.11.18

虽然直接使用会报错并提醒你强制更新，但是我们可以通过一些手段规避这个报错

首先，你应该充分使用搜索引擎，下载到如下文件

双击安装，然后运行，发现报错

这里使用 win + R 调出运行界面，输入regedit打开注册表

依次找到如下文件

右键点击，找到权限，进入界面

将所有用户的完全控制和读取权限禁用

然后你就可以正常使用这个版本的 Typora 了

Frp导致的一些神必问题

2025-01-14T12:43:47.000Z

与 hexo 有关的神必重定向

昨天在测验网站的时候，发现一个在任何界面点击友链和关于链接时会神秘的重定向到错误地址frp-act.top:3000/links/。而正确地址https://frp-act.top:49191/links/是可以访问的

于是我尝试在nginx配置中修改重定向规则，强制将frp-act.top:3000/links/重定向至https://frp-act.top:49191/links/，结果是两个网址都 404 了

尝试寻找最开始出错的原因，发现hexo在生成静态文件时给出的相对路径是/links，并不包含尾斜杠，在不开隧道的情况下，一般浏览器会自动补上尾斜杠以访问正确地址

在nginx进行反代的环境下，理应也会进行补全，事实上，nginx确实给出了带上尾斜杠的重定向地址，然而其却将frp-act.top:49191这个隧道域名+隧道口重定向为了frp-act.top:3000这种隧道域名+本地端口这种不伦不类的东西

在对 nginx 反代进行了时长 3h 的各种配置组合后，我放弃了对 nginx 的重新配置，完全不能理解其中为什么会出现莫名其妙的 404、403 和 500

于是决定直接修改服务器中生成的静态文件

使用 vscode 通过 ssh 连接服务器

当然不可能用 nano 或者 vim 这种编辑器去进行 160 处修改，这里我们选择天下第一的 vscode

在 vscode 上下载 remote-ssh 插件，点击左侧边栏的远程资源管理器

点击新建远程，在上边栏中输入

1	ssh 用户名@服务器ip

按下 enter,系统会自动进行配置，按照引导一路向下，即可在服务器中安装 vscode server，从而使用 vscode 进行远程操作

这里注意给电脑开上代理，不然无法下载 vscode server

然后可以通过 vscode 的查找功能统一替换错误的相对地址

使用 git 上传静态文件

直接通过hexo d上传静态文件非常方便，我们对服务器端 git 稍作配置

首先，如果你的服务器没有 git（树莓派就没有），可以运行

1	sudo apt-get install git

下载 git

然后在一个合适的地方，比如/home/kpmark/（kpmark 是我的用户名）新建一个 git 仓库存放我需要的 hooks

使用以下命令新建文件夹（或者你已经用 vscode 远程控制了，直接右键新建即可）,并在文件夹中初始化一个 git 裸仓库

1
2
3

mkdir /homek/kpmark/git
cd /homek/kpmark/git
git init --bare hexo.git

进入该仓库，在 hooks 文件夹中新建文件post-receive，并写入以下内容

1	git --work-tree=/home/kpmark/hexo-blog --git-dir=/home/kpmark/git/hexo.git checkout -f

这里前面的地址是你博客静态文件所在的地址，是该 git 仓库的工作地址，后面是你 git 仓库的位置，这条命令会强制更新你工作目录的文件

在/home/kpmark/下创建.ssh文件夹（如果你没有的话），然后将你 windows 电脑的 ssh 公钥复制到其中的 authorized_keys 文件中

最后修改 hexo 配置，在_config.yml文件中，修改 url 为你的域名，修改 deploy 为

deploy:
  type: git
  repository: kpmark@ip:/home/kpmark/git/hexo.git
  branch: master

这里如果你有公网 ip 就直接写上去，非常方便

如果开隧道的话，必须对 ssh 进行额外配置，这里不赘述，因为会非常影响你其他需要 ssh 的仓库，建议之间局域网 ip 算了

至此，配置成功

搭建自己的 web 服务器

2025-01-13T12:43:47.000Z

前言

正好手头有一个树莓派，想着加一个 web 服务器的功能就折腾了一下，如果只是想搭载自己的博客建议还是使用云服务器，毕竟树莓派确实不便宜(

准备工作

树莓派（我用的型号是 4b）
sd 卡（建议 32G 以上）
读卡器
一台能正常工作的电脑

这里 web 服务器中搭载的内容是简单的静态博客页面，使用 hexo 搭建博客网站的方法这里不再赘述，可以在本站的关于中查看相关教程

如果不使用树莓派等本地 linux 服务器进行配置，可以跳过树莓派配置部分

树莓派配置

系统烧录

我们拿到树莓派时是一个空板，所以我们需要自行烧录系统

理论上可以烧录任何你喜欢的系统，这里我们为了配置方便与以后的其他用途选择树莓派官方的 RaspberryPi OS ——一个基于 debian 的 linux 系统

进入树莓派官网，下载烧录工具，我们在 windows 设备上进行烧录

按照引导一路安装，完成后打开烧录程序

在 CHOOSE DECVICE 中选择自己的树莓派型号，这里选择Raspberry Pi 4

然后选择你需要的操作系统，这里一般为 Raspberry Pi OS(64 bit)，若不需要图形界面的话可以选择对用的 lite 版本

这里我觉得命令行很帅，所以使用的 lite 版本，后续内容均基于命令行操作演示

由于我手边并没有显示器，因此选择在自己的 windows 系统上使用 ssh 进行连接，在烧录系统时注意设置自己的用户名、密码与 wifi，方便使用在终端使用 ssh 进行连接

然后选择你自己的 sd 卡，进行烧录即可

ssh 连接

首先确认你的电脑上有 ssh.exe 这个文件，一般电脑上有 git，文件中是自带 ssh.exe 的，关于 git 的使用请参考关于中的教程

这里为了方便我们使用 cmd 或者 powershell 进行命令行操作（git bash 确实不太方便），我们将 git 文件夹中的 ssh.exe 加入环境变量

然后，打开你的终端，输入

1	ssh <树莓派的ip>

如果不知道 ip 是什么，可以输入

1	ping 主机名 // 未修改默认raspberrypi

然后输入你烧录系统时设定的密码，注意输入的密码不会显示在终端中

出现以下提示

表示你已经成功通过 ssh 连接至你的树莓派了

配置 Ningx

下载

将自己的服务器用作 web 服务器，我们需要对其进行反向代理，这里我们使用 Ningx 来进行配置

首先在服务器中下载 Nginx

1	sudo apt -y Nginx // -y表示自动确认

然后启动

1	sudo systemctl start nginx

现在你通过同局域网的设备访问树莓派 ip,可以看到如下页面

代表 Nginx 下载成功

配置文件

这里假设我要将我的博客文件放在/home/username/hexo中，我需要将对应监听的端口指向blog中的index.html文件

这里我们在etc/nginx文件夹下新建一个vhost文件夹来存放我们自定义的配置信息，例如，我想将 3000 端口对应至我的博客页面

server {
    listen 3000;
    location / {
            root /home/yourname/hexo; //注意将yourname换成自己的用户名
            index index.html;
    }
}

然后，我们需要在/etc/nginx/nginx.conf文件中的 http 代码块内加入include /etc/nginx/vhost/*.conf;来添加所有 vhost 下的配置文件

此外，我们将需要将nginx.conf文件中的user字段设为自己的用户名，以解决访问限制问题

使用sudo nginx -t来检测是否有语法错误，无误后使用sudo systemctl restart nginx重启 nginx 代理

现在访问你树莓派对应的端口，就可以定向至树莓派内文件所在的位置，接下来我们将 windows 上的静态博客页面迁移至树莓派

博客迁移

这里埋个坑，目前我直接将 hexo 的静态文件手动转移至树莓派，实际使用 git 进行管理会更加方便

在电脑中的 hexo 文件架内，使用hexo generate在public中生成对应的静态文件，运行以下命令

1 2	cd public tar -czvf hexo-blog.tar.gz *

将对应的静态文件打包

然后，使用 ssh 自带的 scp 工具将压缩包转移至树莓派。假设树莓派 ip 为192.168.1.100，目标目录是 /home/kpmark/hexo:

1	scp hexo-blog.tar.gz kpmark@192.168.1.100:/home/kpmark/hexo

然后，在树莓派中运行以下命令解压文件：

1 2	cd /home/kpmark/hexo tar -xzvf hexo-blog.tar.gz

此时通过局域网访问树莓派对应的端口，即可看见你的博客页面

内网穿透

为了在公网中能够访问自己的博客，我们需要一个公网 ip 以及对应的域名

然而目前国内公网 ip 的获取较为麻烦，我们可以采用内网穿透式服务器能够面向公网，这里我选择Sakura Frp

首先，进入官网，注册账号，进行实名认证（需要一元巨款）

然后点击服务，进入软件下载

这里我们跳过启动器，直接安装frpc使用命令行进行操作

找到你服务器设备架构对应的软件版本，如若不确定可以在服务器端输入uname -u来进行确认

这里我的树莓派是Linux AArch64(arm64)版本，注意不要和amd64搞混

不想折腾也可以使用Docker进行部署，但是我比较喜欢手操的感觉

以下操作需要取得root权限，请使用sudo -s命令进行切换

对照官方文档，我们使用cd /usr/local/bin进入对应的文件夹，然后使用以下命令进行下载:

# 一般来说只需要使用这条命令:
wget -O frpc <下载地址>

# 如果上面的命令报错，请尝试这条:
curl -Lo frpc <下载地址>

# Linux frpc 通常已经过 UPX 压缩，如需下载未压缩的版本请在下载地址尾部加上 _noupx

下载地址直接在版本页面复制连接即可

然后设置权限并校验文件完整性

chmod 755 frpc
ls -ls frpc
md5sum frpc

如果操作全部正确，此时可以运行frpc -v来查看版本

在服务页面的隧道列表中新建列表，注意输入你服务器的 ip 和要监听的端口号

再右侧操作中找到配置文件，复制密钥即可，然后再服务器中运行：

1	frpc <复制内容>

即可开启隧道，此时可直接通过隧道给出的 ip 或域名从公网访问网站

https 与 http

如果你的网站申请过 https，那应该是可有照常访问的，如若没有，请在隧道设置中开启自动 https 选项

服务器编程概述

2024-06-22T02:16:46.000Z

互联网是如何工作的

当两台电脑需要工作的时候，我们必须以有线或无线的方式将其连接(两重方式本质上并无不同)

通常一个网络不限于两个电脑，所以我们可以将所有电脑连接只一个叫路由器的特殊小电脑上。由路由器来接受并转发信息。

构成网络

我们将路由器之间再相互连接，规模会不断的扩大，越来越接近我们脑海中互联网的规模。

然而，在现实中为每个家庭每个人架设专用的电缆将不同的网络连接起来是不可能的，那么我们改怎么处理这件事？

电话基础设施已将每家每户进行覆盖了，我们可以使用调制解调器将网络信息转变为电话设施可处理的信息来利用这些设备。

(由于科技的发展，很多地区已经实现光纤入户)

我们将自己的网络连接至互联网服务提供商(ISP)—-一家可以管理一些特殊的路由器的公司。这些路由器连接至其他ISP的路由器，进而实现信息的交互。

(国内的电信、移动、联通均为 ISP 供应商)

什么是 web 服务器

硬件部分，web 服务器是一台存储了 web 服务器软件以及网站的组成文件的计算机。

软件部分，web 服务器包括控制网络用户如何访问托管文件的几个部分，至少是一台 HTTP 服务器。

文件托管

严格来说，你可以在你自己的计算机上托管所有的这些文件，但是在一个专用的 web 服务器上存储它们会方便得多。

专用 web 服务器可用性更强（会一直启动和运行）
除去停机时间和系统故障，专用 web 服务器总是连接到互联网。
专用 web 服务器可以一直拥有一样的 IP 地址，这也称为专有 IP 地址（不是所有的 ISP 都会为家庭线提供一个固定的 IP 地址）
专用 web 服务器往往由第三方提供者维护

通过 HTTPS 交流

web 通过**超文本传输协议(http)**来和 web 服务器进行交流。当你在网页上点击一个链接，或提交一个表单，再或进行一次搜索时，一个 HTTP 请求就从你的浏览器发送到了目标服务器。

一个 HTTP 请求包含所请求资源的URL，定义所需操作的方法，编码在 URL 参数的附加信息。

Web 服务器等待客户端的请求信息，在它们到达的时候处理它们，并且回复 Web 浏览器一个 HTTP 响应信息。

一个 HTTP 相应包含一个显示请求是否成功的状态行(比如 404 not found)。

相应一个请求的成功回应包含被请求的资源，然后这些会被展示在客户端的 Web 浏览器上。

动态网站

一些相应内容只有在被需要的时候才会在网站中生成，在一个动态网站中，页面通常是通过将数据库的数据植入到 HTML 模板中的占位符而产生的。

大多数支持动态网站的代码必须运行在服务器上。编写这些代码就是所谓的服务器端编程(有些时候也称后端脚本编写)。

对于动态资源的请求则会指向(2)服务器端代码 (在图中显示为 Web Application)。在处理动态请求时，服务器会首先解释请求，从数据库中读取被请求的信息，然后将这些被检索的信息组合到HTML 模板中(4),最后返回一个包含所生成的HTML 页面的回应(5,6)。

web 服务器编程

服务器端的代码可以使用任何一种语言编程，比较受欢迎的包括 PHP(狗都不用)、Python、Ruby 和 C#。服务器端代码有充分的权限访问服务器的操作系统。

开发者通常使用 web 框架来编写代码。

客户端 web 框架主要简化布局和演示任务，服务器 web 框架提供大量的普通 Web 服务功能，比如支持会话、支持用户和身份验证、简单的数据访问、模板库等。

客户端框架通常被用来帮助加速客户端代码的开发，但是你也可以选择手写所有的代码；事实上，如果你只需要一个小型的、简单的网站 UI，手写自己的代码可能更快并且更高效。

相反的，你应该从来没有考虑过不使用框架而直接编写 web 应用程序的服务器端组件——实现一个重要的功能比如 HTTP 服务器真的很难直接从头开始用、Python 语言构建，但是一些用 Python 语言写的 web 框架，比如 Django 提供了开箱即用的功能，同时还包含其他很多有用的工具。

web 服务器端可以做什么？

信息的高效存储和传输
定制用户体验
控制对内容的访问
存储会话和状态信息
通知和通讯
数据分析

详见MDN 服务端编程介绍

kpmark

浅读 GS-meta

GS-meta

前置

Abstract

Introduction

Related Work

Graph Sampling-based Meta-Learning

Problem Definition

Molecule-Property Relation Graph

Subgrapha Sampling Scheduler

Training and Testing

Expriments

RQ1

RQ2

RQ3

RQ4

复现

浅读 MAML

Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks

Abstract

Intro

Model-Agnostic Meta-Learning

Meta-Learning Problem Set-Up

A Model-Agnostic Meta-Learning Algorithm

浅读 Flatten Transformer

Flatten Transformer

Abstract

Intro

Related Works

Vision Transformer

Linear Attention

Preliminaries

Vision Transformer and Self-Attention

Linear Attention

Focused Linear Attention

Focus ability

Feature diversity

Focused linear attention module

浅读 Attention is all your need

Transformer

Abstract

Intro

Model Architecture

Encoder and Decoder

Attention

Scaled Dot-Product Attention

Multi-Head Attention

FFN

Train

Code

东莞和 vivo 和 aigc

夏令营

发布会

决赛答辩

Tauri 安卓踩坑笔记

Tauri 安卓踩坑日记

打包签名 apk

使用 HTTP 客户端插件

使用 SQL 插件

构建配置

类型转换

使用自定义动态库

devzat 使用指北

devzat 简介

快速启动

环境要求

快速启动

不快速的启动

WebSocket 原理与 Go 语言实现

从 HTTP 到 Websocket

二者关系

升级过程

握手请求

响应

TCP 连接复用

Go 语言实例

来看代码

依赖

实例化 WebSocket 升级器